CPANscan

Amazon::API is a lightweight, generic Perl client for calling Amazon Web Services that you can use directly for simple REST-style requests or as a base class to generate full, service-specific modules from Botocore metadata with the included amazon-api tool. It focuses on giving you a DIY kit to install and call only the AWS methods you need while handling signing, content-type selection, pagination and response decoding so you can talk to most AWS services without a large SDK. The module works best when you generate stubs and shape classes from Botocore metadata so requests and responses are serialized correctly, it integrates with a small credential provider and supports debugging and different error-handling modes, and the author explicitly recommends Paws for users who want a full-featured, community-supported SDK. Recent updates in the 2.4.6 release improve parameter validation and give you global control over validation level via VALIDATE_MODE, add support for loading and unloading header-located request members, and harden serialization around blobs and timestamps so Botocore-based requests are more reliable. It is production-ready for many APIs but the author cautions that some services have unique quirks and that S3 in particular is better served by dedicated S3 modules.

String::Super is a small Perl utility for packing a set of strings into a single compact superstring that contains every input as a substring. You feed it raw 8-bit blobs with add_blob or text with add_utf8, then call compact or simply ask for result or offset which will trigger compaction automatically. The module trades off between optimality and computation cost to produce a reasonably small result rather than trying to solve the NP-hard exact problem, so it is useful for reducing duplication, packing resources, shrinking embedded data, or aiding simple compression and string-analysis tasks. It is binary safe and returns both the combined blob and the byte offsets of each original input via offset. An experimental prefix_blob option lets you pin one blob to offset zero when absolute placement matters, though that can force less efficient packing. Recent releases added the experimental prefix_blob feature and a minor spelling fix; the API is straightforward and the module dies on error to make failure handling explicit.

Amazon::Credentials is a Perl utility that locates and returns AWS credentials by walking a configurable chain of providers until it finds usable keys. It supports credentials from environment variables, container endpoints (ECS, Lambda, Fargate, EKS Pod Identity), EC2 instance profiles via IMDSv2, OIDC web‑identity tokens (EKS IRSA and GitHub Actions), and local AWS config/credentials files including credential_process and SSO. The module exposes a simple constructor with options to control search order, timeouts, caching, region and logging, plus helpers to check expiration, refresh temporary tokens, and fetch SSO role credentials or set environment variables for them. Security-conscious defaults include IMDSv2 enabled and closure-based storage of secrets so they do not appear in dumps or logs. You can avoid metadata timeouts by setting AWS_EC2_METADATA_DISABLED, lowering the timeout, or supplying an explicit search order. One limitation is that it will not automatically resolve role profiles that require assuming a role via a source profile in the credentials file, though web‑identity federation is supported. Recent 1.3.2 fixes improve web‑identity error reporting and token handling and add JWT claim decoding.

File::URIList is a compact Perl utility for reading and writing URI list files under RFC 2483 so you can parse, produce, or transform lists of URIs in a predictable way. It offers streaming reads via callbacks or bulk reads into an array, and lets you append URIs or comments back to the file, with automatic conversion of plain strings into URI objects and integration with the Data::Identifier family for optional type conversion. The reader exposes configurable policies for blank lines, extra surrounding spaces, missing schemes, and leading slashes, and you can supply a base URI to resolve relative entries which is useful when working with M3U-style files. The module defaults to strict parsing and will die on errors, and its rewind and clear operations require a seekable filehandle so be careful when mixing reads and writes. The current release also exposes a media_subtype accessor and includes dependency fixes.

XML::Sig is a Perl toolkit for creating and verifying XML Digital Signatures according to the W3C XML Signature standard. It lets you sign XML fragments or whole documents with a private key or embedded X.509 certificate and verify signatures using the public key delivered with the signature, making it useful for SAML, SOAP, and other XML-based authentication scenarios. The module supports RSA, ECDSA, optional DSA, HMAC, and x509-encoded signatures and implements common canonicalization methods and the enveloped-signature transform so signatures remain valid across equivalent XML representations. Configuration options let you supply key and certificate files or text, choose digest and signature hash algorithms, control X509 encoding, set which node ID to sign, and omit the XML declaration for fragment signing. After verification XML::Sig exposes the signer's certificate and lists of verified IDs or element nodes so you can confirm exactly which parts of the document were covered and defend against signature-wrapping attacks. The module depends on XML::LibXML, Digest::SHA and various Crypt::* libraries for the required crypto support.

Punk::Queue is a durable, database-backed job queue for Perl that implements its hot paths in C for speed and atomicity. Jobs are stored as rows in SQLite or PostgreSQL and are claimed and recorded by multiple worker processes so work survives crashes and restarts. It provides a rich enqueue API with priority, delay, dependencies, uniqueness keys, per-queue and per-task defaults, and a worker runtime that atomically dequeues, performs and records results or failures. Retries use randomized exponential backoff to avoid thundering herds and three layers of timeout handling protect the system while the supervisor can forcibly kill long-running children. The queue preserves a full per-job log across attempts, offers migration and schema versioning, a repair action to tidy crashed state, simple leasing and counted locks, broadcasting to workers, and admin-friendly listing and stats endpoints. Because Punk::Queue delivers at-least-once semantics tasks must be idempotent by design. This is the initial 0.01 release.

Kubernetes::REST is a Perl client that exposes a simple, high level REST interface to the Kubernetes API and returns typed IO::K8s resource objects instead of raw hashes. It implements standard CRUD operations like list, get, create, update, patch and delete plus convenient helpers such as ensure, ensure_all and ensure_only for idempotent apply and pruning, and it supports streaming operations like watch and log. The client automatically builds API paths from resource metadata, can fetch the cluster resource map from the OpenAPI spec by default, and provides utilities for schema comparison and for async wrappers such as prepare_request, build_path, process_watch_chunk and process_log_chunk. Authentication is token based and the HTTP transport is pluggable so you can use the default LWP backend, HTTP::Tiny or supply an async backend that consumes the Role::IO interface. Note that duplex operations like exec, attach and port_forward require an IO backend with call_duplex and are not supported by the default sync backends. The module also supports multiple patch strategies, handles common race conditions during ensure, and is well suited for scripts, CLIs or integrating Kubernetes access into Perl services.

IO::K8s provides typed Perl objects and serialization helpers for working with Kubernetes resources, letting you convert between JSON, YAML and Perl structures while ensuring the correct types that Kubernetes expects. It can load and validate YAML manifests including multi-document files, collect validation errors, construct objects programmatically, serialize to YAML or JSON, and save manifests to disk. The module supports Custom Resource Definitions by letting you write small CRD classes or by auto-generating classes from a cluster OpenAPI spec, and it can merge external resource maps such as Cilium to add third‑party CRDs and handle name collisions. IO::K8s is designed to work with Kubernetes::REST for live CRUD operations and exposes convenient methods like inflate, json_to_object and object_to_struct to move data between formats. Be aware that the library was rewritten for this major release, moving from Moose to Moo and replacing individual List classes with a unified List class, so upgrading may require code changes.

Container::Buildah is a Perl wrapper around the buildah command that lets you script multi-stage OCI/Docker-compatible container builds from Perl, running each stage as a callback inside the container's user namespace so you get the flexibility of code rather than a static Dockerfile. You define stages with init_config, provide a function for each stage, and Container::Buildah hands a Stage object into those functions with convenience methods that mirror buildah subcommands, which makes it easy to pipeline artifacts from build stages into runtime images and to perform rootless builds. The module is aimed at developers who want programmatic, scriptable control over container construction using buildah instead of hand-edited containerfiles, and it requires a Linux kernel of version 2.8 or newer. Recent releases focused on documentation and examples and added a configurable option around image history handling along with tests for kernel compatibility.

Container::Builder is a Perl toolkit for assembling OCI-style container archives that you can import with podman or Docker by composing layers from Debian .deb packages and local files. It gives simple, Dockerfile-like operations to add Debian packages or package files, extract files from packages, copy directories, add files or string content, create users and groups, set environment variables, working directory and entrypoint, and then produce a single tar archive when you call build. You can point it at a nearby Debian mirror, pick an OS version, enable caching of downloaded .debs and choose whether to gzip-compress layer tars to trade speed for disk space. The module is aimed at crafting minimal, reproducible Debian-based images for development, testing and build experiments rather than as a full production image builder, and the author notes it is still early in development. Recent releases added the ability to embed a container name so podman load can auto-tag the image and fixed digest/diffID handling to produce correct layer and config checksums.

Mojolicious::Plugin::BarefootJS plugs the BarefootJS server runtime into Mojolicious so you can call a per-request BarefootJS instance from your controllers and templates via the bf helper, render compiled BarefootJS templates as Mojolicious templates, and drive server-side rendering using the BarefootJS::Backend::Mojo adapter. It keeps integration simple and framework-native while the separate BarefootJS::Backend::Xslate offers the same runtime for non-Mojolicious or PSGI hosts. A recent improvement changed how the build manifest is loaded so it is read lazily and cached by mtime/size, which prevents boot-time race issues and allows manifest updates to be picked up without restarting the server.

BarefootJS::Backend::Xslate provides a simple Text::Xslate (Kolon) rendering backend for the BarefootJS runtime, letting you render .tx templates on the server without any specific web framework so it works equally well in PSGI/Plack apps or plain scripts. It is designed to be used with the @barefootjs/xslate compile-time adapter which emits Kolon templates that call the runtime as a bf object, so helpers become bf methods and the default Xslate instance needs no special function map. The backend builds Xslate for HTML auto-escaping, supports marking raw HTML when a helper intentionally emits markup, and implements the runtime-facing operations you need: rendering named templates with bf bound, JSON encoding, and materializing values. You can construct it from a prebuilt Text::Xslate object or by passing template paths and Xslate options, making server-side rendering of Kolon templates straightforward and safe for BarefootJS projects.

BarefootJS is a lightweight server-side runtime for marked templates produced from JSX or TSX that lets compiled templates call runtime helpers at render time while remaining agnostic about your template engine or web framework. It handles tasks like JSON marshalling, marking raw strings, materializing JSX children and invoking named sub-templates, but delegates the framework- and engine-specific work to a pluggable backend so you only load the pieces you need. Ready-made backends include Text::Xslate for PSGI/Plack and a Mojolicious plugin, and the core itself uses only Perl core modules to keep the runtime minimal. Use BarefootJS when you want to run JSX/TSX-style templates on the server in Perl and keep your rendering stack flexible and easy to integrate.

IO::K8s::Deprecated is a tiny CPAN distribution that preserves old IO::K8s module names by shipping "tombstone" redirect stubs so that installing a removed or renamed module yields a clear, actionable error pointing to the replacement instead of silently reinstalling stale code. It exists because the CPAN index keeps module names forever and an in-distribution removal can orphan a name, so these stubs reclaim those names and guide users to the current API. The package itself is just a documentation landing page and the individual tombstone modules carry no runtime dependency on IO::K8s core. The initial 1.105 release consolidates 76 per-resource List classes to redirect to IO::K8s::List and also provides tombstones for four removed dynamic resource allocation classes that have no direct successor, making this release useful if you need explicit guidance when encountering legacy IO::K8s module names.

Kubernetes::REST::Deprecated is a CPAN distribution that preserves clear, actionable redirects for old Kubernetes::REST v0 module names that were removed from the main distribution. Instead of allowing tools like cpanm to repeatedly reinstall obsolete stubs, this package supplies tiny "tombstone" modules that immediately fail at load time and tell the user which modern Kubernetes::REST API to use. It covers the large bulk of the old per-endpoint v0 API, providing 1012 redirect stubs plus ten helper-module tombstones, while deliberately not tombstoning the still-working V0Group compatibility shims. The distribution exists purely to register those replacement stubs on PAUSE and to ensure anyone attempting to install an old class sees a clear migration path rather than silently getting dead code.

Math::Prime::Util is a comprehensive, high-performance Perl toolkit for working with prime numbers and related number theory tasks, offering fast sieves, primality tests (including BPSW and provable proofs), integer factoring, prime counting and nth-prime routines, random and provable prime generation, modular arithmetic, combinatorics and many utility functions for integers and sequences. It is implemented in XS for native-speed operations and can use a GMP-backed backend for much faster big integer work, though pure-Perl fallbacks exist; if you plan to work with large integers or cryptographic primes, installing the GMP backend is strongly recommended. The API covers both convenience iterators (forprimes, prime_iterator) and low-level routines (mulmod, powmod, invmod, sqrtmod), handles bigints transparently, is thread-safe, and ships small command-line tools for quick prime and factor tasks. If you want to generate, test, count, or manipulate primes or do heavy integer arithmetic inside Perl, this module is likely relevant and performant for your needs. In the recent 0.75 release the module now requires Perl 5.8.1 or later, the XS selection must be done before loading (prime_set_config can no longer toggle the XS option), and integer results that exceed native size are returned using the user-configured bigint class by default, so take care when upgrading code that depends on previous bigint behaviors.

Math::Prime::Util::GMP is a high-performance Perl extension that brings GMP-backed big-integer math and a comprehensive suite of number‑theory tools to Perl programs, making it ideal for prime testing, factorization, cryptographic key generation, and numeric experiments. It provides fast probabilistic and deterministic primality tests (including BPSW, Miller‑Rabin, Lucas variants, Proth, LLR and ECPP proofs), a range of factoring algorithms (trial division, Pollard Rho/Brent, p-1/p+1, ECM, SQUFOF and a quadratic sieve), sieving and prime‑generation utilities, modular arithmetic and root routines, combinatorial and special functions such as factorials, Bernoulli numbers, zeta and Pi, and a CSPRNG with random prime and proven‑prime generators. Inputs and outputs for large values use strings so you can work with big integers without changing your bigint setup, and the module is the fast GMP backend for Math::Prime::Util. The recent 0.54 release adds several usability and API improvements such as accepting negative inputs to factor, allowing lucas_sequence to take arbitrary integer P and Q, expanded multifactorial support, new small-integer helper functions, and various correctness and performance fixes including a faster BPSW path, so it is a solid choice if you need reliable, production‑grade big‑number arithmetic and prime/factoring capabilities in Perl.

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.

Data::URIID is a utility for extracting identifiers and human-friendly metadata from URLs, QR codes and related objects so applications can display, link or otherwise act on internet resources. You create an extractor, call lookup on a URI or QR/code text, and receive a Result object that exposes IDs (by type) and attributes such as display names, icons or thumbnails, with support for both offline and optional online lookups and configurable user agent and language preferences. The module integrates with Data::Identifier and understands many common identifier schemes, barcodes and special URI forms (geo, ni, tag:, acct: and more), offers selective control over which services are allowed to go online, and is useful when you need to normalize resource references or gather the minimal data required to connect a resource to other services. Recent updates improved the documentation and added basic support for ibb.co images while continuing to expand recognition of well known IDs and formats.

Dist::Zilla::PluginBundle::RSRCHBOY is a ready-made Dist::Zilla bundle that captures the author RSRCHBOY's preferred distribution build, test, metadata and release setup so you can apply his conventions by adding [@RSRCHBOY] to your dist.ini. It assembles a curated set of plugins for things like metadata generation, POD weaving and stopwords, test helpers, Git and GitHub automation, release signing and post-release install steps, while allowing you to tune bundled plugins by passing Plugin::Name.option entries in dist.ini. If you want to inspect exactly what it will do first, the companion Dist::Zilla::App::Command::dumpphases makes the phases easy to review. The bundle is actively maintained and configurable via options such as sign, tweet, github and install_on_release, and note that recent behavior in version 0.078 defaults to not tweeting or signing releases; report bugs or feature requests on the project's GitHub issue tracker.

Sim::OPT is a Perl toolkit for steering and automating parametric optimization and exploration workflows that drive text‑based simulation models. It helps you generate and morph input files, run batches of simulations, and search a multidimensional parameter space using overlapping block searches that mix sequential and parallel update strategies, with options for factorial, star, face‑centered composite designs and metamodel‑based searches. The framework can operate by launching simulations or by mining precomputed results, records clear instance naming and mapping for traceability, and includes utility modules for model morphing and specialized tasks such as ESP‑r shading tweaks, creating AutoCAD 3D plots from parallel coordinates, and building sparse-data metamodels. The distribution provides an "opt" entry command, example workflows for ESP‑r and EnergyPlus, and runs on Linux. Sim::OPT is dual licensed with the open source copy available on CPAN under GPL v3 and additional proprietary components offered by the author, and the changelog in this release contains the original packaging metadata.

Catalyst::Plugin::Session::Store::DBIC lets you persist Catalyst web application session data directly in a database using DBIx::Class, making it easy to plug sessions into your existing DBIC models without writing custom storage code. It acts as a thin wrapper around Catalyst::Plugin::Session::Store::Delegate, so you get straightforward mapping of session id, data and expiry fields to a DBIC result class while still being able to fall back to the Delegate module for more advanced control. Configure it by naming the DBIx::Class result source (dbic_class) and optional field names for id, session_data and expires, and be aware that session data is MIME::Base64 encoded and can trigger warnings if your database column is too small so use MEDIUMTEXT or larger for heavy sessions in MySQL. The module does not auto-clean expired rows so you should run delete_expired_sessions periodically or via a scheduler. Recent fixes addressed a bug where changing a session id could produce a “row not found” error, so upgrading to the latest release is recommended.

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.

Net::WoRMS is a small Perl wrapper around the World Register of Marine Species (WoRMS) SOAP API that powers the query-worms utility, providing web access, parsing and simple output formatting through a Moo object and SOAP::Lite. It exposes easy-to-use methods to search species by name, fetch a taxon record by AphiaID, page through child taxa and print results in TEXT, CSV or SQL formats, and it includes a debug mode and hooks to change the SOAP endpoint, namespace and output format before initialization. The module is aimed at developers who need quick, scriptable access to WoRMS data from Perl or command-line tools and favors simple integration over heavy abstraction. Recent work focused on documentation polish and CPAN deployment fixes so installation and usage should be more straightforward; the module does depend on SOAP::Lite and a small Moo-based type layer.

App::GHGen is a command line tool that generates, checks, and optimizes GitHub Actions workflows so you can add or maintain CI with minimal effort. It can auto-detect your project type or let you choose from templates for Perl, Node, Python, Rust, Go, Ruby, Docker, and static sites, then produce opinionated workflows with dependency caching, concurrency controls, proper permissions, and common lint and coverage steps. It also analyzes existing workflows for performance, security, cost, and maintenance problems, offers cost estimates, and can safely apply fixes or open a pull request with suggested changes; it can even run inside GitHub Actions to comment on PRs or act as a CI quality gate. Perl projects get special attention with multi-OS and multi-version matrices, smart minimum-version detection, CPAN caching via local::lib, cross-platform syntax checks, optional Perl::Critic and coverage, and sensible defaults that you can customize. If you want to reduce CI minutes, keep Actions secure and up to date, or automate workflow maintenance across many repositories then this tool is likely relevant. The recent 0.08 release bumps the Perl setup action and fixes analyzer false positives around outdated runner detection while tightening matching logic and aligning analyzer and fixer rules so flagged issues are reliably fixable.

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.

Net::SAML2 is a Perl library for implementing the Service Provider side of SAML 2.0 Web Browser Single Sign On, letting your application create AuthnRequests, sign and verify Redirect and POST bindings, process responses from Identity Providers, decrypt EncryptedAssertions and generate or consume metadata. It is mature and widely tested against providers such as Auth0, Microsoft Azure, Google GSuite, Okta, Keycloak, ADFS and Shibboleth, and supports both signing and signature verification workflows. Recent releases harden security by requiring a trust anchor (cacert or cert_text) for Response and Assertion verification, add defenses against XML signature wrapping, and fix several CVEs, so upgrading is recommended. Note that Net::SAML2 is SP-side only and expects XML metadata from the IdP.

File::Rotate::Simple is a lightweight, no-frills Perl utility for rotating files by renaming them with numeric suffixes so you keep a simple set of backups. It can increment existing rotation numbers, limit kept files by count or by age in days, and is usable via an object interface, a legacy method call, or an exported function for quick scripts. You can customize the starting number, apply timestamped extensions using strftime with a special %# placeholder for the rotation number, replace or append extensions to preserve original suffixes, and optionally touch the file after rotation. The time attribute accepts Time::Piece and, since v0.4.0, DateTime::Lite and DateTime::Tiny objects. The module intentionally keeps behavior simple and does not track or fill gaps in rotation sequences. Recent changes include enhanced time object support and a security fix to avoid touching destinations of dangling symlinks when rotating (CVE-2026-17435). Note that current releases require Perl 5.14 or later and older Perl users should use the v0.2.x series.

Params::Get provides a single helper, get_params, that turns whatever a Perl caller might hand your subroutine into a consistent hash reference so you can write one simple normalisation call at the top of each public method instead of reimplementing argument parsing over and over. It understands the common Perl styles including a lone hashref, named key/value pairs, a single scalar tied to a default key, an arrayref shorthand or \@_, scalarrefs, CODE refs or blessed objects, and an arrayref of positional key names, and it pairs nicely with Params::Validate::Strict and Return::Set to enforce input and output contracts. The function returns a hashref on success or undef in the documented empty case and will croak or confess on misuse so bugs are reported from the caller frame. Be aware of a few documented limitations such as the fast-path that treats a single hashref as the hash rather than as a value for a default key, ambiguity when a caller passes a single empty arrayref, silent overwriting of duplicate keys in flat lists, and the lack of a way to mark a scalar default as optional. The current 0.16 release tightens edge-case handling, removes some redundant checks, improves performance of common paths, and adds extended security and unit tests.