CPANscan

PAGI::Nano is a compact Perl micro-framework built on PAGI-Tools for demos and small web apps of roughly under 20 endpoints. It gives you a simple DSL that returns an assembled PAGI app instead of mutating globals so apps are composable, nestable, and testable. It provides HTTP routing with named routes and path placeholders, raw handlers for full control, per-route and app-wide middleware, lifecycle hooks with a shared app state, static file serving, streaming, WebSocket and SSE support, and a tiny three-scope service registry. Handlers use sensible return-value coercion to JSON or text and the framework includes strong-parameters for asynchronous input parsing. Builders run eagerly at startup and must be synchronous, there is no automatic service teardown, and mounted Nano apps do not run their own startup/shutdown or declare services, so it is best suited to small, self-contained apps that benefit from a readable single-file structure while still exposing the underlying PAGI primitives when you need them.

PAGI::StructuredParameters is a lightweight, no-dependency Perl utility that whitelists and reshapes incoming request parameters into well-formed nested data before they reach your model or validator. It understands flat form and query keys like "name.first" and "email[0]" and reconstructs them into nested hashes and arrays while simply whitelisting already-nested bodies such as decoded JSON. You interact with it through a lenient permitted() call or a strict required() call that invokes a caller-supplied callback for missing keys, and there are convenient request adapters for body, query, or decoded-data sources with async support. The module also offers sane defaults for array flattening and protects you from abusive input with a configurable maximum array depth that raises an exception when exceeded. This initial release is a focused, decoupled port of the core of Catalyst::Utils::StructuredParameters intended to sit upstream of validation rather than perform validation itself.

DBIx::Class::Valiant plugs the Valiant validation system into DBIx::Class so you can declare filters and validations on your result classes or columns and have them run automatically when records are created or updated. If validation fails the database operation is aborted and you get back the DBIC result object with the attempted values and an errors collection you can inspect, which makes wiring server-side form handling and error reporting straightforward. It also supports nested creates and updates with accept_nested_for, aggregates errors across related records and will roll back the whole changeset on failure, and it honors validation contexts like create and update. You can declare validations inline in add_columns, use it schema-wide by adding components to base result/resultset classes, and it integrates with DBIx::Class::Candy. Be aware nested validation support and many-to-many handling are still evolving and require careful use of prefetch and parameter sanitization to avoid edge cases and security issues.

Valiant is a domain-level validation framework for Moo or Moose objects that gives you a compact, Rails-style DSL to declare attribute and model validations, apply input filters, and collect human-friendly error messages instead of raising exceptions at construction time. You can write simple coderefs, reuse or extend validator classes, or plug in Type::Tiny constraints, and Valiant bundles many common validators plus internationalization, nested object/array support, an Errors collection with message formatting and JSON output, and helpers for generating HTML form elements. It is intended for business-logic and form validation where invalid but well-formed objects must be reported back to users rather than aborting execution. Note that the project recently refocused the distribution so the core framework is now framework-agnostic and ORM/web integrations such as DBIx::Class::Valiant have been split into separate distributions, so upgrading may require installing those companion dists.

PAGI::Middleware::Session::Store::Cookie provides a simple way to keep session data on the client by encrypting it into the cookie so you can avoid server-side session storage. It uses AES-256-GCM for authenticated encryption and derives the key from a required secret you pass to new(), and its async API returns Futures for set (which produces the encrypted blob to store in the cookie), get (which accepts that blob and returns the decoded session hash or undef on tampering) and delete (a no-op for cookie-backed sessions). Because everything lives in the cookie you must keep session payloads small to avoid the roughly 4KB browser cookie limit and you cannot revoke sessions without introducing server-side state such as a blocklist. Recent important fixes include replacing an insecure rand() fallback with Crypt::PRNG to generate IVs (security fix CVE-2026-5087) and declaring the PAGI::Tools runtime dependency to prevent installation/runtime failures.

PAGI::Tools is a convenience toolkit for building applications on top of PAGI, the Perl Asynchronous Gateway Interface, that saves you from hand-emitting low-level protocol events by providing request and response objects, routing, a middleware suite, high-level endpoint helpers for HTTP, SSE and WebSocket, test utilities, and assorted composition and lifespan helpers. It lets you write normal handler code or mount ready-made apps and responses, then run them on any PAGI server or embed them inside larger PAGI apps, so authors exploring PAGI or building higher-level frameworks get a consistent, ergonomic base. Recent notable changes include the distribution split that formalized PAGI::Tools as its own package and a breaking API shift where PAGI::Response is a value and endpoint handlers return response values instead of sending them directly, so upgrading callers should check the new return-and-respond pattern. The toolkit continues to evolve with practical fixes and features such as better session handling for non-HTTP scopes, improved CSRF options, and a new constant-time compare utility used by security-sensitive components.

RPi::PWM::PCA9685 is a pure-Perl driver for the NXP PCA9685 16-channel, 12-bit PWM and servo controller accessed over I2C from a Raspberry Pi. It gives a simple object interface to set a single PWM frequency for all channels and control per-channel duty, phase or raw on/off ticks at 4096 resolution so LEDs and hobby servos are driven in hardware with almost no CPU overhead. The module supports percentage or tick duty settings, microsecond servo pulses, hard on/off, phase control, inversion and an open-drain sink_mode for wiring LEDs to an external supply, and it exposes low-level register access plus sleep, wake and reset operations. It is pure Perl but uses RPi::I2C for the bus transport so it runs on Linux, and new() wakes and verifies the chip for you. This initial release adds the OO API, examples and documentation, bundled datasheet, and the new drive and sink_mode conveniences, making the module a practical choice if you want to manage many PWM channels from a Pi without writing low-level I2C code.

CPAN::Perl::Releases is a small utility module that provides a static mapping from Perl release versions to the CPAN "authors/id/" paths where the release tarballs are stored. Its main function, perl_tarballs, accepts a Perl version string and returns a hashref that maps compression types such as "tar.gz", "tar.bz2", or "tar.xz" to the relative CPAN path for that tarball, or undef if the version is not known. Not all releases have every compression format so results vary. The module also offers perl_versions to list all known Perl releases in ascending order and perl_pumpkins to list the PAUSE IDs of Perl maintainers. The mapping is packaged as static data and the module is updated when new Perl releases are uploaded to CPAN. Use this module when you need to programmatically locate or construct CPAN URLs for specific Perl release tarballs or to enumerate available Perl versions.

Module::CoreList is a Perl library and command line tool for discovering which modules and versions shipped with each Perl release, letting you quickly answer questions like when a module first became part of core, whether a given module and version is bundled with a particular Perl, or what changed between two Perl releases. It offers a simple programmatic API with functions such as first_release, first_release_by_date, is_core, find_modules, find_version and changes_between, and exposes data hashes including %Module::CoreList::version, %delta, %released, %families, %upstream and %bug_tracker for deeper inspection. Use it to search core modules by regex, check deprecation or removal history, find upstream/bug tracker info for core libraries, and automate compatibility or packaging checks. The module is actively maintained and its data are regularly refreshed for new Perl releases, most recently updated to include Perl 5.44.0.

CPANSA::DB provides the CPAN Security Advisory dataset as a ready-to-use Perl data structure. It exposes a single subroutine, db, which returns a hashref containing all advisories and is primarily used by CPAN::Audit but can be used by any code that needs programmatic access to CPAN security reports. Each release includes a .gpg signature and GitHub attestations so you can verify the archive and module file, and a JSON file with the same data is also available for non-Perl consumers. The project is published on GitHub with attestations and GPG signatures to help ensure you are using authentic advisory data.

Net::Blossom::Server::Backend::S3 is a storage backend for Net::Blossom::Server that stores blob data in S3-compatible object stores like Amazon S3, Ceph, or Garage while leaving descriptor and owner metadata to a separate MetadataStore (for example SQLite or Postgres). It stages uploads on disk and automatically uses single PUTs or multipart uploads depending on file size, streams downloads with ranged reads so object bodies are not held in memory, and exposes configuration for bucket, endpoint, region, credentials, multipart thresholds, temporary directory, and custom S3 clients. The module implements the Net::Blossom::Server::Storage interface and provides hooks such as a post-commit cleanup error handler and a pluggable object-key generation function for testing. Because metadata and object storage cannot be committed atomically, failed metadata commits or deletions can leave unreachable objects, so buckets must be precreated and operators should monitor cleanup errors. If you need S3-compatible blob storage for a Blossom server with configurable upload behavior and streaming reads, this module is a ready-made option.

Mojolicious::Plugin::Fondation::Perm::UI::Bootstrap adds a ready-made Bootstrap 5 user interface for assigning permissions to groups in apps using Fondation::Perm. Install it in your Mojolicious config and it injects a permissions section into the group add/edit modal and ships two JavaScript helpers. loadPerms() pulls the permission list from /api/perm, renders the checkboxes and prechecks those a group already has. collectPermAssignments() returns the checked permission IDs for use when saving a group. This plugin is ideal when you want a simple, drop-in UI for managing group permissions that integrates with DatatableGroup.js.

Mojolicious::Plugin::Fondation::Group::UI::Bootstrap is a Mojolicious plugin that adds a Bootstrap 5 web UI for managing user groups, acting as the front end to the Fondation::Group backend. It injects a multi-select group picker into user add/edit forms, extends the user list with a groups column that renders memberships and marks inactive groups in strikethrough, and provides a standalone /groups page with a DataTable plus inline add, edit and delete modals guarded by the appropriate permissions. The plugin ships client scripts for fetching groups and wiring the UI, exposes loadGroups and collectGroupAssignments hooks for user forms, and includes English and French translations. It depends on the Fondation group backend and the Bootstrap layout plugin and was first released on 2026-07-15.

Test2::Plugin::Cover is a lightweight coverage helper for Perl tests that records which source files a test actually touched with very low overhead. It uses a small XS hook to note filenames when subroutines run and when files are opened, then attaches that minimal coverage map to a Test2 event at test exit so harnesses like Test2::Harness can consume it. This is not a full line or branch coverage tool like Devel::Cover but a practical way to determine which files a test exercises so you can select or optimize which tests to run after code changes. The module exposes simple APIs to query the files and structured data, to manually touch coverage entries, to enable or disable collection, and to tag or group calls with set_from/get_from for subtest attribution. There are known limits because magic such as eval, goto, inlined constants, XS subs, threads and some exotic open() forms can mask filenames or be unrecordable. The most recent release focused on robustness and performance by making touch_* respect disable, turning internal failures into warnings instead of dying, deduplicating and deterministically sorting caller metadata, caching control flags in XS to reduce per-call overhead, re-enabling the sysopen hook and fixing memory leaks and crash risks. If you want fast, low-cost mapping from tests to touched files this module is a good fit, and if you need exhaustive coverage reporting you should prefer Devel::Cover.

Mojolicious::Plugin::Fondation::Menu is a plugin for the Mojolicious web framework that gives your app declarative, database-backed menu and breadcrumb management. Menus are declared in a simple share/menus.json file shipped with each plugin and then synchronized into the database with a provided menu sync command. The module stores titles, links, FontAwesome icons, grouping names, parent/child relationships, ordering, visibility flags and simple conditions such as group:NAME or perm:NAME so you can show items based on role or permission. It exposes handy helpers for controllers and templates like menus, menu_by_name, menu_by_id, breadcrumb, render_menu and render_menu_breadcrumb, and it includes an auto-generated REST API with CRUD endpoints and permission checks for menu_read, menu_create, menu_update and menu_delete. Use it when you need a maintainable way to build dynamic navbars and breadcrumbs that respect user roles and plugin-provided menu definitions.

Mojolicious::Plugin::Fondation::Authorization is a small plugin for the Fondation stack that loads a user's group-based grants from the database and gives your app simple synchronous helpers to check permissions and group membership. On the first authenticated request in a session it loads permissions asynchronously with an around_dispatch hook and stores them in the session so subsequent requests do not hit the database. Permissions are inherited through group membership only, following the chain user -> user_group -> group -> group_perm -> perm, and the plugin exposes check_perm and check_group helpers for use in controllers and templates. It depends on the Fondation Auth, Group and Perm plugins for authentication and the underlying DB models, so it is a drop-in way to add cached, database-driven access control to a Mojolicious application.

Data::Checks supplies a ready-made set of value-constraint checks for Perl plus an XS-level framework so other modules can build and enforce those checks efficiently. You can import named constraints like Defined, Object, Str, Num, Maybe, Any and All, or use parametric checks such as StrEq, StrMatch, NumEq, NumRange and the various NumGT/GE/LE/LT forms, and there are handy reference and capability checks like ArrayRef, HashRef, Callable, Isa and Can. It integrates cleanly with attribute and operator-based systems so you can declare checked parameters or use "is" style tests, and each constraint is usable as an object with a ->check method for programmatic testing. Authors of XS modules get helper functions to construct and assert checks at the C level and to emit useful error messages. Note that plain CODE refs as constraint specs were deprecated to improve error reporting, and the most recent release includes a compatibility fix so the module builds cleanly against the latest Perl versions.

Mojolicious::Plugin::Fondation::Auth is a small Mojolicious plugin that adds ready-made DBIx::Class backed login and logout routes and ties them into the Fondation user model and Mojolicious::Plugin::Authentication so you get authentication routes, session handling and helpers out of the box. It delegates actual credential checks to a configurable provider so you can keep the default DBIx provider or swap in LDAP or another system, while password hashing with Argon2id is performed by the user Result class so the plugin only verifies credentials. The plugin ships a login template and translations, exposes helpers like is_user_authenticated, current_user, authenticate and logout, and expects a simple user table with username and hashed password columns. Defaults include a 30 minute session timeout and a configurable session key and column names, and recent updates simplify schema mapping by using the result_class name and add better setup and integration with the Fondation User UI bootstrap. If you need a drop-in, DBIx-aware authentication layer for a Mojolicious app that can be extended to other providers, this module provides a practical starting point.

Mojolicious::Plugin::Fondation::Perm is a small plugin that brings permission management to applications using the Fondation toolkit on the Mojolicious web framework. It is intended to help developers enforce access control within Fondation-based web apps by integrating permission checks into the normal Mojolicious workflow. The module is authored by Daniel Brosseau, carries version 0.01, and is distributed under the same license as Perl itself. Use it if you need a lightweight, framework-native way to add permission handling to Fondation projects.

Mojolicious::Plugin::Fondation::Group is a lightweight plugin for the Mojolicious web framework that adds group management features tailored to the Fondation ecosystem. It helps developers handle group creation, membership and basic access grouping in a consistent way with Fondation conventions so you can add role- or group-based behavior to your web apps without building that infrastructure from scratch. If you are building a Mojolicious application on Fondation and need a simple, ready-made way to manage user groups and memberships this module is directly relevant. This is the initial 0.01 release.

Aion::Annotation is a small utility for extracting in‑code annotations from a Perl project's lib tree and dumping them into simple, machine‑friendly files under an annotation directory. It scans source comments and markers like @todo, @deprecated and @param and writes a modules.mtime.ini to track file modification times, a remarks.ini with comment blocks for packages, subs and attributes, and per‑symbol .ann files that record package, symbol, line number and the annotation text so you can generate todo lists, deprecation reports or lightweight documentation indexes. The input and output paths are configurable via the AION_ANNOTATION_LIB environment variable and the AION_ANNOTATION_INI and AION_ANNOTATION_CACHE settings so it fits into different project layouts. The module records line numbers and groups entries by package and name to make it easy to locate the source of each note. The 0.1.0 release updates configuration handling to use Aion::Env rather than requiring a separate config file.

Business::ISBN::Data is a data pack that supplies up‑to‑date ISBN range and publisher information to the Business::ISBN module so it can validate, parse, and interpret ISBNs correctly. You normally do not load it directly because Business::ISBN loads it for you, and it contains the RangeMessage.xml from the ISBN Agency plus a built‑in fallback dataset exposed in %Business::ISBN::country_data with a _source field showing the origin. If you need a newer or custom RangeMessage.xml you can point the module at it with the ISBN_RANGE_MESSAGE environment variable or place the file in the current directory, which avoids reinstalling the module. The distribution includes the XML and offers packaging tips for tools like PAR. The data are updated frequently and recent releases include fixes for ISBN‑13 handling, so make sure you use Business::ISBN 3.005 or later. The source is on GitHub and the code is redistributed under the Artistic License 2.0.

CallBackery is a Mojolicious-based application class that supplies the plumbing for building appliance-style web frontends and REST RPC endpoints. It handles configuration loading (defaulting to etc/callbackery.cfg with an environment override), exposes a pluggable database interface, and lets you declare security headers to harden browser clients. It also wires an RPC service namespace and controller and provides a starting document for built-in documentation links. Use it when you want a ready-made Mojolicious startup hook and common frontend infrastructure for device or appliance web UIs without reinventing configuration, database access, or basic security headers.

sshca is a small, command-line SSH Certificate Authority that helps you create a CA directory and issue SSH user and host certificates from public keys, making it easy to adopt short-lived certificate-based SSH authentication. The tool tracks issued certificates and serial numbers, supports adding principals and certificate options, can renew certificates using previous request data, list and filter certificates, and clean up expired certs. Configuration is handled with a YAML file and defaults to ed25519 keys and sensible validity windows, while environment variables and command-line flags let you override behavior. Storage is currently filesystem-based with planned support for database backends, and features like revocation and history are noted as future work. Overall it is a simple, practical choice for sysadmins who want a lightweight way to tighten SSH access without deploying a complex CA system.

Data::NestedKey is a compact, object-oriented Perl helper for reading and editing deeply nested hash and array structures using simple dot-separated path strings, with an optional CLI tool called dnk for piping JSON through a query. You wrap your data in a Data::NestedKey object and then use get, set, delete, and exists_key with paths like "a.b[2].c" to fetch values, check presence, or remove items, and negative array indices are supported for get, delete, and exists checks. The set method offers convenient prefixes for common operations, using "+key" to append or merge and "-key" to remove, but it does not accept array subscripts or operate directly on an array-rooted structure so array edits must be done by retrieving and modifying the Perl structure yourself. The object can be serialized back to JSON by default and also supports YAML, Data::Dumper, and Storable output, making it handy for tweaking configuration files or API responses when you need something simpler than a full jq dependency.

Apache::Solr is a high‑level Perl client for talking to an Apache Solr search server, letting you run searches, manage facets, highlights and suggestions, add or delete documents, commit or optimize indexes, and even invoke Solr’s Tika-based extraction to turn files into searchable documents; it supports both XML and JSON exchanges and provides a smart result object that preserves paging, timing and trace information while integrating with Log::Report for flexible logging and error handling. The module simplifies Solr parameter syntax for Perl, maps Perl booleans to Solr booleans, preserves request ordering, shares an LWP::UserAgent across instances, and offers configurable retry behavior for transient communication failures. It also exposes core management actions such as reload, status and unload, and warns about deprecated or removed Solr parameters to help maintain compatibility with specific server versions. Note that the field_key_simplify feature, which lets you use underscores instead of dots in nested field names, has a historically awkward default and is deprecated, and the recent 1.12 release fixes underscore handling while requiring Perl 5.16.1.

Cucumber::Messages is a Perl library that implements the Cucumber messages protocol and provides Perl classes for every message type used across the Cucumber ecosystem, together with NDJSON serialization and deserialization. It lets you build, inspect and emit Envelope-wrapped messages that Cucumber tools expect, for example converting Location, Attachment or TestCase objects to and from JSON with methods like to_json and Envelope->from_json. Use it when you need to integrate Perl test runners, formatters or reporters with other Cucumber components, handle attachments or externalized attachments, or consume/produce NDJSON message streams generated by the broader Cucumber toolchain. The module follows the shared cross-language message schema maintained by the Cucumber project and is kept in step with upstream protocol improvements.

Eshu is a fast, XS-powered tool that normalises leading whitespace in source files for C, Perl, XS, XML/HTML, CSS, JavaScript and POD by tracking nesting and re-emitting each line with correct indentation while leaving the line contents untouched. It understands language-specific constructs such as strings, comments, heredocs, regexes, template literals and embedded POD or script blocks so it produces sensible formatting rather than naive tabbing. You can call it from Perl code, use the included eshu command line for single files or whole trees with language detection, diffs, CI check mode and options for tabs or spaces and indent width, or install the supplied vim plugin for on‑the‑fly fixes. The engine is written in C for speed and runs as a single pass scanner, making it suitable for automating style fixes in projects and CI pipelines. Recent updates fixed incorrect indentation for certain preprocessor prototypes and expanded test coverage across languages to improve reliability.

Template::EmbeddedPerl is an embedded-Perl template engine that lets you place Perl code directly in template files or strings using familiar <% ... %> and <%= ... %> tags to generate HTML or other text formats. It provides features web developers expect such as optional automatic HTML escaping with raw/safe helpers, a cache for compiled templates, single-line interpolation, and helpers for partials, layouts and named content blocks, and it also adds an experimental typed-view system for composing nested view objects. Its distinctive advantage is correct block capture so you can embed map or sub blocks with template fragments naturally without awkward begin/end markers, making some patterns much cleaner than in Mojo::Template or Mason while remaining conceptually similar to those systems. Templates are compiled into a dedicated namespace to isolate symbols but this is not a security sandbox so only compile trusted templates. The recent 0.001016 release added smart line directives and declarative named template arguments, improved argument validation and diagnostics, and expanded partials, layout nesting and typed-view resolution to simplify building reusable view components. This module is powerful for projects that need flexible block capture or typed views but it is newer than some alternatives and the author notes there may still be undiscovered bugs, so choose it when its unique features matter.

Net::Curl::Promiser wraps libcurl's multi interface in a simple Promise-based API so you can do asynchronous HTTP and other transfers without wrestling with low-level polling, callbacks, or timers. It is a base class with ready-made subclasses for Mojolicious, AnyEvent, IO::Async and a plain select() loop, and you can add curl easy handles with add_handle to get back a Promise that resolves with the handle or rejects with an explicit error; you can also cancel or fail handles, pass through setopt and inspect active handles. The module detects common memory-leak patterns and warns during global destruction unless you disable that behavior. By default it uses Promise::ES6 except the Mojo subclass which uses Mojo::Promise and there is experimental Promise::XS support via an environment variable. Recent updates let the Mojo subclass run with a custom event loop and improve test reliability on Linux. This module is useful if you want a higher-level, promise-friendly way to drive libcurl from Perl and you are using one of the supported event systems or are willing to write a small subclass for another event framework.