CPANscan

OpenAPI::Modern is a Perl library for validating HTTP requests and responses against OpenAPI v3.0, v3.1 and v3.2 documents, letting you check that incoming or outgoing traffic conforms to your API specification and extract deserialized parameter and body data for further use. You build an OpenAPI::Modern object from an OpenAPI document or schema and it uses JSON::Schema::Modern to perform fully standards‑compliant JSON Schema evaluation, returning a rich result object that contains validation errors, populated data, and optional default values. The module is designed to work natively with Mojolicious request and response objects and will convert common request/response types from other frameworks on a best effort basis while also offering helpers to locate operations, resolve $ref chains, and cache parsed documents for faster startup. It bundles the official metaschemas and supports content encodings, multipart/form-data and media type based parameter deserialization, and includes debug hooks to help trace matching and decoding. Note that some niche OpenAPI features are not implemented and there are caveats around parameter percent‑encoding, certain multipart types, and automatic verification of Authorization headers, so review the documented limitations if you rely on those behaviors.

Audio::Scrobbler2 is a Perl client for the Last.fm scrobbling API that implements the desktop authentication flow and the basic track submission methods needed to report now-playing status and to scrobble played tracks. It uses HTTPS with verified TLS and UTF-8 form encoding, requires an API key and secret to create a client, and can request and store an authorized session key for authenticated calls. You use track_updateNowPlaying to set the current track and track_scrobble to submit a played track, with track_scrobble requiring a positive Unix timestamp for when playback started. All failures raise exceptions and the module deliberately does not retry requests to avoid creating duplicate scrobbles, so your application should handle any retry or recovery logic.

Marpa::R2 is a powerful Perl parsing framework that can recognize any language you can write in BNF, including left and right recursion, ambiguous and even infinitely ambiguous grammars, and it aims for linear-time parsing for practically used grammars. Its friendliest entry point is the Scanless interface (SLIF), which lets you declare grammars in a compact DSL, mix lexical rules with structural rules, use longest-acceptable-token matching, and attach Perl callbacks to compute semantic values as the parse tree is evaluated. For advanced needs you can drop down to a thinner interface that talks directly to the underlying libmarpa engine. Note that Marpa is intended for trusted input only because taint mode disallows SLIF with tainted data, and all Marpa objects that share a grammar must be created and used in the same thread. The module is maintained on CPAN under the LGPL and is supported on a volunteer basis.

Lingua::famibeib is the top-level Perl module for working with famibeib, an artificial language, and serves as the entry point to a small ecosystem of helpers for parsing, manipulating, and generating famibeib text. It ties together submodules that focus on text handling, sentence-level operations, and word-level details while integrating with Data::Identifier so words and modifiers can be registered and discovered. The distribution includes practical features such as number-word parsing, main-verb resolution and other grammar-aware utilities, and it also provides experimental tools like a proper-name generator and visual markers for words in display modules. Recent updates added a Wellknown helper module, IDE annotations, improved verb and adjective parsing, and support for registering generators, making the package convenient for developers building parsers, generators, or language tooling around famibeib.

Devel::MAT::Dumper is a small utility module that writes a snapshot of a running Perl process to disk so you can inspect its heap later with Devel::MAT::Dumpfile and related tools. It provides non-exported functions to write a PMAT-format heap dump to a file or filehandle and can be configured at import time to automatically dump on die, warn, END, or on receipt of signals (including an unsafe SIGABRT handler to capture native/XS context). You can control the output filename (with an NNN token for unique numbering), the maximum string length to capture, and whether the file is opened eagerly. The module is useful for diagnosing memory leaks, crashes, and mysterious runtime state on production or remote systems where analysis tools may not be installed. It was split out from the main Devel::MAT distribution so the dumper can be deployed independently. Recent updates add support for Perl internals changes such as Magic v2 from Perl 5.45.2 and related bug fixes to stay compatible with newer Perls.

Devel::MAT is a Perl Memory Analysis Tool that loads heap dump files and gives you a framework for inspecting and diagnosing memory use in Perl programs. It wraps a dumpfile and lets you list, load and run analysis plugins that follow the Devel::MAT::Tool API, and it integrates with a UI layer so tools can present interactive views. Common tasks include tracing inbound reference chains back to known roots with configurable depth and filtering options, and locating symbols, globs or stashes in the captured symbol table. The module is aimed both at end users who want to hunt down leaks and at developers who want to write custom analysis tools. The dump file format is still evolving so cross-version loading is not strictly guaranteed, though newer releases have improved forward compatibility. If you need to explore a Perl heap dump or extend a memory-analysis toolkit Devel::MAT is directly relevant.

RT::Extension::ResetPassword adds a simple, self-service "Forgot your password?" link to the front of an RT instance and emails users a one-time URL to reset their RT-managed password. It also adds an admin control on the user page so administrators can send reset emails for new or locked-out users and view or delete a user�s password status. The extension only resets passwords stored by RT and cannot change passwords kept in external authentication systems such as LDAP, SAML, OAuth, or Active Directory. You can tune behavior with options to hide error details, change the reset link lifetime and From address, disable the login-page link, allow users without passwords to set one, or even create new users and set them as privileged, and the author warns that enabling account-creation or privileged defaults can be risky unless access to the web UI is restricted. The module is updated for RT 6.0 and recent releases restored a missing Back to Login link on the reset form.

EV::Future is a tiny, high-performance XS library that gives you a handful of simple async control-flow primitives for the EV event loop, including parallel, parallel_map, parallel_limit, series, series_map and race, so you can run many callbacks at once, map workers over lists, limit concurrency, run steps sequentially, or take the first result. Each primitive supports two forms: a task form where each element is a coderef that receives a single done callback, and a map form where a worker is called for each data element as (item, done). In non-void context each call returns a lightweight EV::Future::Handle that can report progress with active and pending and can cancel further dispatch, and every primitive has a safe default mode plus an optional faster unsafe mode that improves throughput at the cost of letting exceptions escape and risking counter corruption on double-done. The module is extremely fast compared with common Perl promise libraries according to its benchmarks, and the author documents a few gotchas you should know such as treating non-coderef task entries as instant no-ops, requiring plain arrays for task lists, final callbacks not being validated, and never passing the raw done callback directly to an EV watcher. Recent releases added the map-family functions and race, introduced the handle API and other robustness fixes, and raised the minimum Perl to 5.14.

PAGI::FastAPI is an asynchronous micro-framework for Perl 5.36+ that brings a FastAPI-like developer experience to Perl by combining non-blocking request handling via the PAGI spec and Future::AsyncAwait with Type::Tiny-based validation for query parameters and JSON bodies. It offers an async middleware pipeline, a simple dependency injection helper, a built-in CORS helper, and automatic OpenAPI 3.1 generation plus an interactive Swagger UI at /docs so your API is documented and discoverable out of the box. Routes are declared with async handlers and optional type constraints or dependency specs, validation errors are returned as HTTP 422 responses, and the app produces a PAGI-compatible code reference you can run with a PAGI server. The initial CPAN release implements the async routing engine, type-safe parameter and body validation, middleware and CORS support, dependency injection, and integrated OpenAPI/Swagger endpoints, making it a good fit if you want to build scalable, type-checked REST services in modern Perl.

Bluesky is an object oriented Perl client for the Bluesky social network that wraps the AT Protocol so you can authenticate, read feeds, post content, and manage social relationships without learning low level protocol details. It supports both app-password and OAuth flows and includes a convenient oauth_helper that can run a local HTTP listener to capture the redirect for interactive apps. You can fetch timelines, feed generators, post threads and individual posts, stream real time events with a firehose client, and create rich posts with images, video, URL cards, mentions, tags and reply controls; file upload helpers and blob uploads are included. Social graph and moderation actions are covered too, with follow, block, mute, list management, reporting, and notification APIs. The module also exposes actor and profile lookup, search, preferences, identity resolution, and a full set of direct messaging and conversation methods, making it suitable for building bots, command line clients, or integration code that needs to drive Bluesky from Perl.

Return::Set provides a single exported function, set_return, that returns a value and can optionally validate that value against a strict Params::Validate::Strict schema. You can call set_return with just a value to return it as-is, with a value and schema to validate before returning, or with a named-parameter hashref using "output" (or "value" for compatibility) and "schema". If validation fails the function croaks, which makes it useful when you want to formally declare and enforce a method's output types, especially when used alongside Params::Get. The module is small and focused, offering a simple way to add declarative runtime checks to your return values.

JSON::Schema::Fast is a high-performance JSON Schema validator for draft 2020-12 that compiles a schema once into a compact intermediate form and then validates Perl data with a tight C interpreter, making repeated validation very fast and allocation-free on the success path. You compile a schema and then call is_valid for a quick boolean check or validate to collect structured errors that include instanceLocation, keyword, schemaLocation and a human message. The module supports a useful subset of draft 2020-12 features including core $ref within the same document, type checks, numbers, strings, arrays, objects and applicators like allOf/anyOf/oneOf, and it offers optional conveniences such as non-destructive coercion of numeric and boolean strings and applying default values into a working copy. It reports unrecognized keywords so you can detect schemas that rely on unsupported features. Remote and cross-document $ref resolution, anchors/$id-relative resolution and unevaluated* semantics are deferred to future releases, so this module is a good fit when you need a fast, local-schema validator with predictable error reporting and a focused, modern feature set.

Datafile::Hash is a lightweight, pure-Perl helper for loading and saving simple key/value files and INI-style configuration files that may include multi-level section names. It reads data into a Perl hash using flat keys, dotted keys, or true nested hashes and offers configurable delimiters, comment characters, header skipping, filtering by string or regex, and safe handling of quoted values. When writing it performs atomic updates, can make backups, insert top comments, set file permissions, and will quote values as needed so round-tripping common config formats is painless. The API returns entry counts and message arrays instead of dying on errors so it is easy to embed in scripts and tools. Recent releases added INI-mode with nested sections, search filtering, verbose diagnostics, atomic writes and improved UTF-8 and test coverage, with the latest update focused on test quality and a repository move.

JMAP::Tester is a lightweight Perl client designed to help developers test JMAP servers by sending method calls, handling uploads and downloads, and inspecting the structured responses that JMAP returns. It wraps requests into JMAP methodCalls, encodes and decodes JSON with support for JSON::Typist typed values, and organizes server output into easy-to-test units called Sentences and Paragraphs with helper methods to assert and extract expected results. The module can obtain and apply client session information for authentication, manage default arguments and capability declarations, and perform raw HTTP requests when you need low level control. It can operate synchronously or return Future objects for asynchronous workflows, and it offers options for pretty JSON output and configurable JSON codecs. The library is still in early development, so expect evolving behavior, but it provides a practical, test-focused way to exercise JMAP endpoints and validate responses.

DateTime::Format::XSD is a small Perl helper that turns DateTime objects into XML Schema xsd:dateTime strings so your timestamps match the exact YYYY-MM-DD"T"HH:MI:SS(Z|[+-]hh:mm) profile expected in XML and many web services. It builds on DateTime::Format::ISO8601 so it can parse a wide range of ISO date formats but always emits the strict XSD representation, making it a good choice when you need predictable, standards-compliant output. The module is lightweight and easy to drop into code that produces XML or interoperable timestamps. The recent 0.5 release includes a dependency update addressing a nanoseconds handling fix and adds a security policy and minor packaging improvements.

CLI::Simple is a lightweight object oriented toolkit for building Perl command line tools that parse Getopt::Long-style options, dispatch subcommands, and handle positional arguments with minimal boilerplate. It is built around the modulino pattern so a single .pm file can act both as a reusable module and as an executable script. For small scripts you subclass and define cmd_* methods, and for larger projects you declare commands and options in a YAML manifest and implement each command as a Role::Tiny role so CLI::Simple composes, dispatches, and scaffolds a role-based layout for you. It also auto-generates getter/setter accessors for options, integrates optional Log::Log4perl logging, supports aliases, default values, bash completion generation, and utilities to dump a manifest or scaffold roles to help migrate existing scripts. The design is intentionally minimal rather than a full framework which makes it a practical choice for internal tools, admin scripts, and projects that want an easy path from a simple script to a composable, testable command suite.

Command::Run is a lightweight Perl utility for running external commands or invoking Perl code references while capturing their input and output. It offers a fluent, chainable interface to set command, stdin and stdout/stderr handling and exposes captured output via a temporary file path like /dev/fd/N so you can hand results to other programs, and it uses only core modules. For Perl code references it can run them in-process (nofork) and optionally in a raw mode to avoid encoding overhead and gain large speedups for tight loops. Recent releases fixed a PerlIO layer leak that affected long-running nofork usage and made run() accept temporary parameters such as command and stderr so passing a scalar reference to run now correctly captures error output.

Amazon::Signature4::Lite is a compact, dependency-light Perl module that builds AWS Signature Version 4 authorization headers for S3 and other AWS services. You create a signer with your access key, secret key, region and optional session token, then call sign with the HTTP method, URL, any extra headers and the payload to get a hashref of ready-to-send headers such as Authorization, x-amz-date, x-amz-content-sha256, host and x-amz-security-token when applicable. The API is designed to work directly with HTTP::Tiny-style scalars and hashrefs rather than LWP or HTTP::Request objects which makes it a good fit for lightweight scripts or environments where you want minimal dependencies. It also offers a helper to extract service and region from common AWS endpoint hostnames but that parsing is tuned to S3/AWS patterns rather than being a general URL parser.

Module::CoreList is a lookup library and command line tool that tells you which modules and which versions shipped with each Perl release. It provides a simple API to answer questions like when a module first appeared in core, whether a particular module and version are bundled with a given Perl, which modules match a pattern across releases, and what changed between two Perl versions. The distribution also exposes ready-made data structures you can inspect from code, such as per-release module/version maps, release dates, deprecation and removal information, and upstream or bug tracker pointers. That makes it useful for CPAN authors, system packagers, and developers who need to know if they can rely on a module being available without installing extra dependencies. There is broad coverage of modern Perls with all stable releases since 5.6.0 and development releases since 5.9.0 included and partial coverage for very old releases. The module is maintained by the Perl 5 Porters and is installed with a command line helper named corelist for quick interactive queries.

CPAN::Perl::Releases is a tiny utility module that maps every Perl release uploaded to CPAN to the relative "authors/id/" path where its tarball lives, making it easy for scripts and tools to locate specific Perl tarballs for download or inspection. You call perl_tarballs with a Perl version and get back a hashref showing available archive formats such as tar.gz, tar.bz2 or tar.xz and their CPAN paths, and there are convenience functions to list all known perl_versions and to list perl_pumpkins, the PAUSE IDs of the authors. The data is static but maintained regularly as new Perl releases and release candidates appear, and the package is kept up to date with recent releases such as the latest 2026 updates for v5.40.5-RC1 and v5.42.3-RC1.

Mojolicious::Plugin::Fondation::Auth::Token provides simple personal access token support for Fondation-based Mojolicious applications by adding an opt-in route condition fondation.bearer that lets API routes accept Bearer tokens. Tokens are random strings whose SHA-256 hashes are stored in an api_tokens table and are meant to be created outside HTTP flows via CLI or fixtures. When a route uses fondation.bearer it will accept a valid Bearer token or a normal cookie session, return 403 for invalid tokens and 401 for unauthenticated requests, and routes that do not opt in will reject any Bearer header with 403. The plugin integrates with Fondation::Auth and the DBIx async model component and works alongside Fondation permission and group checks so you can stack authorization conditions as needed. This is the initial 0.01 release.

CPANSA::DB is a small Perl module that ships the CPAN Security Advisory dataset as a ready-to-use Perl data structure. It exposes a single db function that returns a hash reference of all advisory reports so scripts and tools can programmatically check known security advisories for CPAN distributions. The module is primarily used by CPAN::Audit but can be consumed by any code that needs the advisory data, and a JSON equivalent is also available. Releases are published on GitHub and include GPG signatures and GitHub attestations so you can verify the archive and trust the data before using it.

App::sdif is a small suite of terminal tools for making diffs easier to read and track. The sdif command prints diffs side-by-side with color, column and tab controls and works smoothly as a git pager so you can read git diff, log or show output in a friendly two-column layout. The cdif tool adds fine-grained visual effects that highlight changed words or characters and can use MeCab for better tokenization of Japanese text. The watchdiff utility repeatedly runs one or more commands and displays their output with visual emphasis on what changed so you can monitor live differences. The package is configurable via dotfiles, includes many options for color, visibility and truncation, and recent releases fixed a watchdiff regression so commands actually execute again and restored support for multiple --exec entries.

Mojolicious::Plugin::Fondation::Asset is a thin wrapper around Mojolicious::Plugin::AssetPack that gathers asset rules from all Fondation plugins, merges them into a single assets/assetpack.def file via the included "asset generate" command, and processes those bundles so they are available to your app. The generate command normalizes remote fetch directives so external URLs are treated correctly and caches downloaded files so they are not re-fetched at runtime. At startup the plugin only loads AssetPack if the merged assetpack.def exists, registers plugin public directories as stores, and calls process to expose assets to templates while emitting a warning and continuing if the def is missing. Use the "-y" option to overwrite without prompting. Recent releases require Fondation >= 0.05 to include the built-in share/assets/assetpack.def and add GitHub issue tracking in the module metadata.

Devel::LeakGuard::Object is a small utility for detecting Perl object memory leaks by counting blessed instances per class and reporting any imbalances that indicate leaked allocations. You can track a single object, wrap a block of code with leakguard to catch leaks within that scope, or enable global tracking so every bless is monitored and a summary can be shown at program exit. The leakguard call can warn, die or call a custom callback when leaks are found and offers filtering and tolerance options via only, exclude and expect so you can ignore or allow known, acceptable allocations. The module also exposes leakstate and track for programmatic inspection and a status summary facility. Be sure to load it early so it can intercept bless calls and note that overloading bless makes object creation somewhat slower, although the author reports the slowdown is small for typical programs.

Sys::Async::Virt is an asynchronous Perl client that implements the LibVirt remote protocol so you can control hypervisors remotely or locally using non blocking RPCs. It exposes an object oriented API that maps most libvirt protocol calls to methods which return Futures and can be awaited with Future::AsyncAwait, and it supports event subscriptions and callback objects for domains, networks, storage pools and node devices. The module translates C conventions into Perl friendly types by converting bitmap fields into arrays of booleans and representing typed parameters as descriptive hashes, and it ships with a large set of libvirt constants for flags and event ids. Generated against libvirt protocol v12.6.0, it works with newer servers while calls may fail on older servers that lack specific features, and the distribution is currently experimental with a few documented limitations and unimplemented entry points such as some file descriptor related calls. Choose this module when you need programmatic, asynchronous control of libvirt managed resources from Perl and can tolerate the noted gaps in protocol coverage.

Mojolicious::Sessions::Store provides server-side session storage for the Mojolicious web framework by replacing the default signed-cookie approach with a model where the browser only holds a signed cookie containing a session ID and all session data is kept in a backend of your choice. It is a drop-in change for application code because the existing session helper works the same, and it supports configurable options carried over from Mojolicious::Sessions such as cookie name, domain, path, expiration, secure and samesite. A simple file-based backend is included and custom backends can be written by implementing load, save and delete methods, so you can store sessions on disk, in Redis, in a database or elsewhere. The module is lightweight and focused on moving session data off the client; the most recent release replaced a dependency with Mojo::Util::random_bytes and updated its GitHub issue metadata.

Protocol::Sys::Virt implements the libvirt RPC protocol in Perl, providing the low-level mechanics needed to build libvirt-compatible clients and, in principle, servers. It follows libvirt's versioning so it stays aligned with libvirt API releases and is particularly useful if you need a nonblocking, asynchronous approach to talking to libvirt from Perl because the higher-level Sys::Virt interface is blocking by design and Perl threading is impractical for that use case. This module is aimed at developers who need direct protocol-level control or want to build an async libvirt client in Perl rather than those looking for a polished, high-level virtualization management library.

Web::Request is a lightweight request object for PSGI/Plack applications that converts the raw PSGI environment into a simple, consistent API for reading client IP and host, scheme, method, paths, headers, cookies, body and query parameters, uploads, URI and session data and for creating response objects. It is designed to be mostly read-only so you should not mutate returned objects, with the single supported exception of the encoding attribute which you can change to control how request body and parameters are decoded and how new responses are encoded. You can construct it from a PSGI env or an HTTP::Request and it defaults to Web::Response for responses and Web::Request::Upload for uploads with iso8859-1 as the default decoding. The API closely follows Plack::Request but is aimed at application authors who want a slightly higher-level, more user-friendly interface. The recent 0.12 release clarifies encoding behavior when creating responses and fixes decoding of undefined query parameters for compatibility with newer URI versions. If you build PSGI apps and want a convenient, well-maintained wrapper around the environment to simplify routing and parameter handling, Web::Request is likely a good fit.

Mojolicious::Plugin::Fondation::Model::DBIx::Async is a Fondation plugin that integrates DBIx::Class::Async with Mojolicious so your DBIC queries run in a background worker pool instead of blocking the event loop. It provides simple helpers like schema_class, schema and model so controllers can obtain native DBIx::Class::Async ResultSets and get Future-based results from operations such as search, create and find. You declare named backends and models in your app config, the plugin auto-discovers Result and ResultSet classes from Fondation plugins, and each backend gets its own lazy-forked worker pool that is cleanly shut down on process exit. This makes it easy to keep web requests responsive while running parallel database work, though you should remember to retain Future chains to avoid premature garbage collection. Recent updates improve many_to_many prefetch handling and upgrade integration with async many-to-many relationship support.