CPANscan

Uniform::Upload::PAGI is a small Perl driver that connects the Uniform::Upload API to asynchronous, non-blocking multipart file uploads running on the PAGI stream pipeline. You explicitly instantiate it with a PAGI connection scope so there is no implicit guessing about the incoming data and it normalizes raw stream payload into file objects you can inspect. Those file objects support chainable validation calls like maximum size and allowed MIME types and provide methods to save files, making it easy to handle uploads inside async event loops without blocking. The constructor requires a valid PAGI scope hash reference so it plugs directly into PAGI-based frameworks.

Uniform::Upload is an abstract, framework-agnostic base for handling multipart form file uploads in Perl that lets you keep upload validation and storage logic portable across web frameworks. Subclasses populate a simple files hash with the raw metadata their environment provides and this base class lazily wraps those entries into Uniform::Upload::File objects so validation, persistence and other higher level operations can be performed consistently. The API includes has_file to check for an upload for a given form field and file to retrieve the wrapped file object, and file will raise Uniform::Exceptions for missing or invalid field names. Do not instantiate Uniform::Upload directly; implement or install a small framework-specific driver such as Uniform::Upload::PSGI and then use the uniform interface for upload handling in your application.

Reverse::Proxy is a lightweight PSGI reverse proxy that forwards incoming HTTP requests to upstream backends using the Fetch HTTP client, and it can be configured to send every request to one backend, route by path-prefix, or pick a target per request via a resolver. It runs on any PSGI server and can operate fully non-blocking on servers that implement psgix.loop and psgi.nonblocking such as Hyperman while falling back to blocking Fetch calls elsewhere, and it manages a per-worker keep-alive connection pool to reuse connections. The module handles standard proxy header semantics and multi-valued headers, supports optional streaming so response bodies are passed through chunk by chunk without buffering, and tunnels Upgrade requests like WebSocket when the server exposes psgix.io, though that tunnel is blocking and will be rejected with 501 on servers that do not provide psgix.io. You can tune behavior with options for host preservation, timeouts, TLS verification, pool size, Via header and streaming, and the proxy re-encodes PATH_INFO on the outbound request to avoid request smuggling.

Fetch is a high-performance HTTP client for Perl that gives you asynchronous futures for every request while also working synchronously out of the box by pumping its built-in event loop. Its performance-sensitive socket, TLS and HTTP/2 code runs in bundled C for low overhead and it supports HTTP/1.1 and HTTP/2, connection pooling, redirects, per-request timeouts, streaming bodies, JSON helpers, a cookie jar and native WebSockets. Each request returns a Fetch::Future you can await with ->get so the same code works for simple scripts and for thousands of concurrent requests on a single loop. Fetch integrates with popular Perl event loops or uses its own standalone loop and exposes a C ABI so other XS modules or proxies can drive it without Perl round trips. It also provides hooks to observe outbound requests and a clone method to cheaply get per-request isolation for things like cookie jars. Recent noteworthy additions include a request-observer API and an ABI version that lets callers upgrade plaintext tunnels to TLS (STARTTLS style) and a recent fix for an io_uring deadline cancellation crash.

PDF::Make is a comprehensive Perl toolkit for generating, parsing and editing PDF files that offers three levels of API to match different needs. At the top is a template-driven Markup API that lets designers write simple document templates and Perl supply the data, a high-level Builder API provides a chainable, layout-aware interface that handles pages, word wrap and font metrics for common tasks, and a low-level XS API exposes the raw PDF primitives when you need full control over content streams and object graphs. The distribution also includes parsing and extraction tools, font and image handling, form and interactive action support, layers, attachments, accessibility helpers, watermarks and redaction, encryption and digital signatures, and output options such as linearisation for web viewing. Runtime dependencies are minimal with Object::Proto for the Builder and Template::Stencil required only if you use the template renderer. Recent maintenance fixes in v0.12 ensure Font::Metrics is properly declared as a prerequisite and address build issues on older Perl versions, making installs more reliable. If you need to produce invoices, reports, complex print-ready output or to inspect and modify existing PDFs from Perl, PDF::Make provides a flexible, well layered solution.

OrePAN2 is a lightweight DarkPAN manager that helps you build and maintain a private CPAN-style archive. You can inject distribution tarballs from a git repository or remote archive and then generate the standard CPAN index file so tools like cpanm can install directly from your local mirror. It provides simple command line utilities and an OO-ish library interface so you can automate or embed it in other tools. OrePAN2 relies on modern CPAN components for parsing and indexing, offers a cleaner API than its predecessor, and is actively maintained, making it a handy choice for teams or individuals who need to host or distribute private Perl modules.

Uniform::HTMX::PAGI is an asynchronous adapter that plugs the Uniform::HTMX layer into the event-driven PAGI HTTP stream pipeline, giving you a clear non-blocking way to detect and handle htmx-driven requests inside a PAGI scope. The constructor validates and prepares a PAGI scope and automatically normalizes inbound header arrays, while apply() commits your accumulated htmx directives into the scope (stashing compiled headers in $scope->{'htmx.outbound'}) and returns the object for method chaining. If you are building real-time or incremental HTML fragments with htmx in an async PAGI environment this module handles the plumbing so you can focus on the response logic. This initial standalone release also stabilizes the asynchronous array-of-arrays request and response header flattening subsystem.

Uniform::HTMX::PSGI is a compact adapter that brings the Uniform::HTMX interface to PSGI/Plack applications, allowing Perl web apps to detect htmx-driven requests and emit the proper htmx response headers or retarget DOM fragments without tying you to a specific web framework. It is framework-agnostic and middleware-friendly, so you can either apply header changes directly to a Plack::Response object or let the adapter stash compiled headers into the PSGI environment for later middleware to apply. You instantiate it with the PSGI env hash and call its apply method to flush response modifiers into the response or into env->{'htmx.outbound'}, which keeps integration straightforward and compatible with existing Plack stacks. The module was released as a production-ready PSGI/Plack connector on 2026-08-22.

Uniform::HTMX::Mojolicious is a compact adapter that makes it easy to handle htmx-driven interactions inside Mojolicious controllers, letting your server detect htmx requests, set response targets and client triggers, and publish the necessary htmx headers. You explicitly construct it with the current Mojolicious::Controller so there is no background auto-detection, it normalizes incoming request headers for you, and it exposes methods like is_htmx, res_retarget, res_trigger and apply so you can build header changes fluently and inject them into the outbound response. Use it when your app serves fragments or partial updates to an htmx-enabled frontend and you want a minimal, predictable way to emit the correct response headers inside Mojolicious routing.

Uniform is a specification and utility anchor for building framework-agnostic web components in Perl. It defines a common interface and shared helper libraries so you can write drivers that wrap different Perl web frameworks and keep your core application logic decoupled from deployment engines like Dancer2, Mojolicious, Catalyst or plain PSGI. The spec requires explicit framework subclasses, fluent mutator methods, an explicit apply() call to flush outbound side effects, and strict fail-fast validation, which together reduce framework lock-in and simplify testing and migrations. The root distribution provides documentation and utilities while companion Uniform::* driver modules implement the concrete behavior for each target framework.

Lingua::Text is a small, practical Perl object for keeping the same piece of text in multiple languages and automatically returning the right translation based on the process or HTTP locale. It overloads stringification so you can print or interpolate a Lingua::Text object directly, provides two-letter language accessor methods and a set() method for runtime updates, can be built easily from key/value pairs or a database hashref, and can convert stored Unicode to HTML entities for safe HTML output. The module memoises locale detection and installs fast accessors for good performance in web scenarios. Be aware that encode() is destructive and cannot be undone, storage keys are effectively two-letter language codes so locale fallback is limited, and typos in auto-generated accessors return undef without warnings. If you need a simple way to manage localized labels and messages in scripts or web apps, Lingua::Text is a convenient fit.

Gzip::Libdeflate is a lightweight Perl wrapper around the libdeflate library that gives you fast DEFLATE-based compression and decompression from Perl with a familiar gzip/zlib/deflate interface. It exposes simple methods to compress and decompress scalars and to read/write compressed files, supports compression levels 0 (store) through 12, and defaults to gzip-format output while letting you choose zlib or raw deflate headers when needed. The module bundles libdeflate so you do not need it installed system-wide, but building the XS component requires an ISO C99 compiler. Error conditions return undef and emit warnings and the file convenience methods use File::Slurper for binary I/O. The current release updates the bundled libdeflate to version 1.26.

Dir::Rename::WD offers a single simple routine, rename_wd, that renames the directory your process is currently in and puts the process back inside the renamed directory. It does this by changing to the parent directory, performing the rename, and then changing into the new name so your program can continue running in the moved directory. The call returns true on success and false on failure, with $! set to explain errors such as missing or extra arguments (EINVAL), attempts to rename root (EBUSY), or inability to chdir back due to permission problems. This module is useful when scripts or tools need to rename their working folder without losing their working directory context, and it is small and focused so you can wrap it in a CLI or larger workflow as needed.

Alien::SNMP builds and installs a pinned copy of the Net‑SNMP C library together with the matching Perl XS modules and command‑line client tools so you can use SNMP from a non‑system Perl or get a selfcontained Net‑SNMP stack for your application. It ensures the SNMP.pm/NetSNMP::* XS modules are compiled against the very same libnetsnmp it installs, provides helper methods to find the shipped binaries and compile/link flags (bin_dir, cflags, libs), and lets you prefer its tools on PATH without disturbing a system Net‑SNMP installation. It does not ship MIB files by default, and it reads snmp.conf and MIBs from its own share and from ~/.snmp rather than from /etc/snmp or system MIB directories, so you must supply any vendor MIBs you need. The build produces client utilities like snmpget, snmpwalk and snmptranslate but not the agent daemon, and macOS users should build with a Homebrew or perlbrew perl rather than Apple’s system perl. Recent updates moved the build to the Alien::Build toolchain and preload the bundled libnetsnmp so the XS modules reliably load the right library, and a recent fix addresses a parallel make race and improves where the Net‑SNMP tarball is fetched from, plus added SECURITY.md for vulnerability handling.

Uniform::HTMX is an abstract, framework-agnostic Perl base for handling htmx client-server interactions that you subclass for your web framework rather than use directly. It normalizes a variety of incoming htmx header spellings and provides simple inspection methods to detect htmx requests and read information such as current URL, target, trigger identity or event payloads, prompts, and history restore flags. It also offers fluent helpers to set outbound htmx response behavior by emitting the proper headers for retargeting, reswapping, reselecting, client-side navigation and history updates, redirects, refreshes, and firing custom client events with automatic JSON serialization. The module sanitizes outbound values to avoid invalid headers and response-splitting, uses JSON::MaybeXS with a JSON::PP fallback for structured data, and is intended to be extended with a small framework-specific subclass that extracts raw headers and injects the module's outbound headers into framework responses.

Punk::Mailer is a small Perl library that builds RFC 5322‑compliant outbound email messages and hands them to configurable transports for delivery. You give it a plain hashref with the usual fields such as from, to, subject, text, html and attachments and it produces 7‑bit clean MIME bytes with the right multipart structure and content encodings, streaming file attachments in chunks so large files do not consume memory. It enforces safety and correctness up front by rejecting header values containing CR, LF or NUL, validating addresses, encoding non‑ASCII display names and subjects per RFC 2047, and generating required headers itself. You can configure transports (smtp, sendmail, resend, capture, log or a custom class) when creating the mailer so transport options are checked early, use send to hand a validated message to the transport and inspect a Punk::Mailer::Result for delivery status, or call build/build_to to get the raw bytes or stream them elsewhere. This is the initial 0.01 release.

Dist::Zilla::PluginBundle::RSRCHBOY is an opinionated Dist::Zilla bundle that packages up the set of plugins and default settings Chris Weyl (RSRCHBOY) uses to build, test, document, and release Perl distributions. Drop [@RSRCHBOY] into your dist.ini and it will wire together common tasks such as gathering files, generating metadata, running tests, shaping POD, updating GitHub metadata, handling release steps, signing tags and release artifacts, and optionally tweeting and installing the built distro locally. The bundle is configurable so you can toggle features like signing, tweeting, GitHub updates, and the post-release install command or pass options directly to the individual plugins. It is useful if you want a ready-made, maintained workflow that follows one experienced author’s conventions or if you want to reuse a curated collection of best-practice Dist::Zilla plugins. Recent changes removed Travis references, refreshed badges, and cleaned up documentation, and the defaults now leave tweeting and tag signing off while GitHub integration remains enabled.

Database::Abstraction is a read-only, ORM-like layer that gives Perl programs a single, simple API for querying data stored as CSV, PSV, XML, SQLite, BerkeleyDB, DBM::Deep or any DBI-compatible database without writing SQL. You express filters as plain values, comparison hashes, pattern and set operators, logical groupings, or by adding join specs, and you can chain queries with the provided Query builder or use AUTOLOAD column shortcuts for quick lookups. Small files can be slurped into memory for very fast reads, DBI statements are prepared/cached for speed, and optional CHI-compatible caching and schema introspection are built in. It is ideal when you need to switch storage formats without changing application code or want lightweight read-only access to a variety of backend files or databases. Note that it is intentionally read-only, the default CSV separator is historically "!" so you may need to set sep_char => ',' for standard CSVs, slurp mode assumes a unique key column and simple XML structures only, and BerkeleyDB has some feature limits. The recent 0.37 release added remote file support so candidate files can be fetched over SSH/SCP into a temporary directory, added DBM::Deep (.dbm/.deep) detection and in-memory support, and tightened identifier validation and other security and stability fixes.

DBD::Pg is the mature Perl DBI driver that lets Perl programs connect to and work with PostgreSQL databases using the familiar DBI interface. It handles connection details and SSL options, supports server side prepared statements and several placeholder styles, marshals Postgres arrays and bytea values into Perl structures, and provides convenient features for transactions, savepoints, bulk COPY I O, large object handling, asynchronous queries and even asynchronous connect. It also exposes rich metadata methods such as table_info, column_info and primary_key_info, plus utilities for quoting, last_insert_id and LISTEN/NOTIFY, so it suits everything from simple scripts to data‑heavy or low‑latency applications. The module is actively maintained and widely used, and recent releases fixed async prepare and COPY TO STDOUT issues and improved SSL documentation, with a very small packaging fix for Mac compilation in the latest point release. If you write Perl that talks to PostgreSQL, DBD::Pg is the standard, full‑featured driver to use.

This Perl module is a client library for Aspose.Cells Cloud that lets Perl applications interact with Aspose's spreadsheet REST API to create, convert, edit, and manage Excel files in the cloud. It provides helper components such as ApiFactory, Configuration and Role to simplify authenticating, configuring endpoints, and constructing API clients so you can upload workbooks, manipulate worksheets, ranges, charts and formulas without dealing with raw HTTP calls. If you need to automate spreadsheet processing from Perl and prefer outsourcing the heavy lifting to a cloud service, this module gives a convenient, higher-level interface to do that.

Punk::TOTP is a small, self-contained Perl implementation of RFC 4226 (HOTP) and RFC 6238 (TOTP) that generates base32 secrets, emits otpauth:// provisioning URIs for QR-based enrolment, creates time- or counter-based one-time codes, and verifies them with built-in replay protection. It includes helpers to produce appropriately sized secrets and RFC 4648 base32 encode/decode that tolerates the spaces and hyphens common in displayed secrets, and the verifier checks a configurable time window with constant-time comparisons and requires callers to supply a stored last_counter to prevent reuse. The module needs no external crypto libraries at install time because HMAC is provided at runtime by File::Raw::Hash, and options let you pick algorithm, digits, period, skew and time for flexibility. Store the secret and the last_counter securely in your database because verification requires the secret, and note that this is the initial 0.01 release.

App::Netdisco packages Netdisco, an open source web-based network management system that helps network teams discover, inventory and control switching infrastructure. It gathers device data via SNMP into a PostgreSQL database and exposes a browser interface plus background daemons so you can locate a host by IP or MAC, see which switch port it sits on, change port VLAN or PoE state, and build hardware inventories and topology views. The distribution is extensible with plugins and a DBIx::Class database layer, ships a built-in web server (default port 5000) and has container images and community support to simplify deployment. It requires Perl 5.10 or later and PostgreSQL 9.6 or later and includes documentation and scripts for installation, initial device discovery and upgrades, making it a practical choice if you need an open, extensible tool to map and manage a switched network.

File::Raw::Hash is a File::Raw plugin that computes digests and HMACs while passing file bytes through unchanged, delivering the resulting checksum into a caller-supplied scalar, hash or arrayref so it works equally well for reads, writes, streaming and per-record processing without loading whole files into memory. It supports a range of algorithms (sha256, sha512, sha1, md5, crc32, xxh64, blake3), multiple output formats (hex, HEX, base64, base64url, raw), and multi-algo runs in one pass for efficiency. All algorithms are vendored reference implementations so there are no external crypto dependencies, and HMAC mode is available for the mainstream digest algorithms. The module keeps legacy and non-cryptographic options like sha1, md5, crc32 and xxh64 for interoperability and fingerprinting but warns they are not suitable for new security designs. A recent change added a C ABI header (frh_abi.h) so other XS extensions can call into its digest and HMAC runner directly.

Amazon::Signature4::Lite is a compact Perl utility for generating AWS Signature Version 4 headers so you can sign S3 and other AWS API requests without pulling in heavyweight HTTP libraries. It is designed to work directly with the simple scalars and hashrefs used by HTTP::Tiny, accepts standard credentials including temporary session tokens, and returns ready-to-use headers like Authorization, x-amz-date, x-amz-content-sha256, host and x-amz-security-token when needed. You construct a signer with your access and secret keys plus region and optional service, call sign with method, URL, headers and payload, and merge the returned hashref into your HTTP client. The module keeps dependencies to Perl core modules, provides a helper to parse AWS endpoint hostnames to extract service and region, and recent releases added an option to include the x-amz-content-sha256 header and fixed S3 path encoding to avoid double-encoding, making it a simple, dependency-light choice for basic AWS request signing.

Mojolicious::Plugin::BarefootJS makes it easy to use the BarefootJS server runtime inside a Mojolicious app by registering a "bf" helper that lazily creates a per-request BarefootJS instance backed by BarefootJS::Backend::Mojo. It lets you render BarefootJS-compiled templates as native Mojolicious templates so controllers and views can use BarefootJS features with minimal setup. If you need the same runtime outside Mojolicious, BarefootJS::Backend::Xslate provides a Text::Xslate-driven option. Install the plugin to add the helper and supporting hooks and streamline using BarefootJS templates in your Mojolicious application.

BarefootJS::Backend::Xslate is a small adapter that lets the BarefootJS runtime render Kolon-style Text::Xslate templates, so you can use BarefootJS templates in any PSGI/Plack app or even a standalone script without tying into a web framework. You give it template directories or a ready-made Text::Xslate instance and it provides the runtime-facing operations the engine expects, such as render_named, encode_json, mark_raw and materialize, while building Xslate with HTML auto-escaping and support for helpers that emit raw markup. It is designed to work with the @barefootjs/xslate compile-time adapter which emits ".tx" templates that call the runtime as a bf object, and it lets you override Xslate options or the JSON encoder if you need custom behavior. The module is actively maintained and available under the MIT License.

BarefootJS is a lightweight server-side runtime for marked templates generated from JSX/TSX that lets compiled templates call back into Perl at render time. It is framework- and template-engine-agnostic, delegating tasks that depend on the rendering environment such as JSON marshalling, raw-string marking, JSX children materialization, and named-template invocation to a pluggable backend so the same runtime can drive different hosts. Shipable backends connect it to common Perl stacks like Text::Xslate for PSGI/Plack or Mojolicious via a plugin, and the core itself only depends on Perl core modules so no template engine or web framework is loaded unless a backend requires one. If you compile your front-end templates to marked templates plus client JS and need a consistent, minimal Perl runtime to render them server-side, BarefootJS provides the bridge you need and is released under the MIT License.

Linux::Event is a Linux-only asynchronous I/O framework centered on an XS epoll reactor and a set of high-level objects for streams, listeners, datagrams, timers, signals, wakeups, and processes. It is designed so you subclass Linux::Event::Stream or Linux::Event::Datagram to implement protocol behavior and then attach those objects to a Loop with MyStream->connect or a Listener that constructs Streams for accepted sockets, while low-level fd readiness remains available through loop->watch. Streams provide buffered reads and writes, native framing, backpressure, half-close and lifecycle hooks, optional OpenSSL TLS via Linux::Event::TLS, and deadline support so you can build robust nonblocking servers and clients without managing epoll directly. The distribution also includes native UDP and Unix datagram support, pidfd-based process spawning and async stdio, signalfd-backed signal handling, eventfd wakeups for cross-thread or post-fork notifications, and structured error and address helpers. It requires a modern Linux runtime and development headers including pidfd support and OpenSSL 1.1.1. The recent 0.101 release stabilizes the public API and adds Wakeup, Datagram, and Process primitives along with production socket policy and lifecycle hardening for real-world usage.

Chem::Structure::Parser is a fast, practical Perl module for reading macromolecular structure files (PDB and mmCIF/PDBx) and returning a single, consistent hash-of-hashes that contains everything a typical script needs: header metadata, per-chain and per-residue annotations, atom coordinates, the observed and SEQRES sequences, element and atom counts, bounding box and B-factors, and convenience views such as flat atom lists, ligand tables and human-readable summaries. It autodetects format (and accepts gzipped files), presents the same keys and numbering whether the source was PDB or mmCIF, and exposes simple entry points like structure_info, structure_sequences, structure_atoms and structure_summary while letting you tune what is returned (which model(s), whether to keep hydrogens, waters, HETATM entries, atom hashes, or header parsing) so large files can be read with controlled memory cost. The coordinate parsing is implemented in C for speed so even very large entries parse quickly, while irregular header parsing stays in Perl to be robust. The distribution also provides residue and residue-type helpers (aa3to1, aa1to3, res1, res_type), a cif_info helper for forcing mmCIF, and functions such as is_single_ion to spot chains that are just a single heterogen. The initial 0.01 release adds mmCIF support, a total_atoms statistic, per-chain element tallies, fixes for legacy PDB column quirks and improved element naming to IUPAC conventions, and includes expanded tests that compare output against independent readers for correctness. If you need a reliable, high-performance way to turn PDB or mmCIF files into queriable Perl data structures for sequence extraction, counting, filtering or downstream processing, this module is directly relevant.

Stats::LikeR brings a compact, high‑quality set of R-like statistics and data-frame tools to Perl with many routines implemented in XS for speed. It covers everything from basic reducers (mean, median, sum, rank, quantile, density) and matrix/PCA helpers to a wide range of hypothesis tests and models (t tests, Wilcoxon/Kruskal, chi-square, Fisher, ANOVA, glm, coxph, survival, ROC/AUC and more) plus data-frame reshaping and manipulation functions you expect from pandas/R such as read_table/write_table, agg/group_by/merge/concat, melt/pivot_table, assign, filter and various converters between AoH/AoA/HoA/HoH shapes. The code emphasizes numerical accuracy and practical behavior, is validated against R and SciPy in many places, and is designed to be usable on real datasets with sensible NA handling and UTF-8 support. If you care about recent fixes, the 0.301 release notably rewrote and hardened kruskal_test: it was cross-validated against R/SciPy, fixed several input and tail-pvalue bugs, reduced memory use and improved speed, and now returns stable, R-compatible results even for tricky inputs. If you write Perl that needs familiar statistical APIs, fast execution and reliable, R-consistent results, Stats::LikeR is likely relevant.