CPANscan

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.

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.

Database::Join is a lightweight read-only layer that lets you present two or more Database::Abstraction objects as a single virtual table by performing an in-memory equi-join on a single key. It exposes the familiar read-only API (selectall_arrayref, selectall_array, fetchrow_hashref, count, columns, schema, updated) and automatically routes query criteria to the backend that owns each column so callers do not need to know which database holds which field. The module supports left, inner and full-outer semantics, per-database permanent filters, join_map to handle differing local key names, remove_columns to hide fields, add_database to grow the view at runtime, logger propagation, and an AUTOLOAD column shortcut for quick lookups. Note that joins are performed entirely in memory so it is not intended for very large result sets, it only supports single-column equi-joins and no raw SQL builder, and count() materialises the full join and counts rows in Perl. This is the initial CPAN release and implements the core features described above.

Finance::MtGox is a Perl client for the MtGox Bitcoin exchange API that lets you make both unauthenticated and authenticated API requests and gives a few handy helpers for common tasks. You instantiate it with your API key and secret, call raw endpoints with call or call_auth and receive decoded Perl data structures, or use convenience methods like balances to fetch BTC and fiat balances, clearing_rate to estimate the market price needed to buy or sell a given amount by walking the visible order book, and market_price to compute a 24‑hour volume weighted USD/BTC price. The module communicates over HTTPS, supports MtGox API v1 and v2, and returns data in ready-to-use Perl form, making it useful if you need to script trading or query account and market data from MtGox.

MCE::Shared is a Perl module for sharing data between threads and processes that makes it easy to expose arrays, hashes, scalars, ordered hashes, sequences, queues, condition variables, file handles and a lightweight DB to multiple workers via a single shared-manager process. It supports deep sharing of nested structures, a tie interface and the mce_open helper for sharing filehandles, optional DBM and PDL integration, and can pass file descriptors when IO::FDPass is available. Concurrency helpers include built‑in mutex locking and atomic pipeline operations to minimize round trips to the manager, plus export and destroy methods to retrieve non-shared copies. The module is designed to work with MCE and MCE::Hobo for thread-like parallelism, runs across platforms including Windows and Android with some caveats, and requires Perl 5.10.1 or later. The changelog notes a recent 1.894 update that refreshes the module license.

Punk::ClamAV is a small plugin for the Punk web framework that scans user uploads with a running ClamAV daemon before you accept or store them. You enable it with a plugin call and point it at your clamd socket, and it provides a helper such as upload_ok that you call on an upload handle to verify the file is clean. It uses the ClamAV::Clamd client underneath, so it can take advantage of the client library features including nonblocking operation, and is a straightforward way to add virus scanning to avatar uploads and other file handlers in Punk apps. A running clamd is required and the module is free software under the Artistic License 2.0.

Teng is a lightweight DBI wrapper and simple object relational mapper for Perl that makes common database tasks easy without heavy dependencies. You define a small schema with a compact DSL and create a model class that extends Teng, then use straightforward methods to insert, fast insert, bulk insert, update, delete, search, run raw or named SQL, and fetch single rows. Row objects are created on the fly and inherit from Teng::Row so you do not need to write a class for every table unless you want custom row methods. Teng also provides transaction helpers, pluggable SQL builder support, options to control how rows are created, and a plugin loader to extend behavior. It is designed for simplicity and ease of installation and was forked from DBIx::Skinny. Teng does not include Perl-level trigger hooks so use Moose, Mouse, or method modifiers if you need that kind of interception.

Test::Time is a tiny utility for making time-dependent Perl code easy to test by overriding the core time, localtime and sleep functions so you can freeze and drive the perceived clock. You load it and optionally set an initial time with use Test::Time time => 123, after which time() and localtime() report the controlled value and sleep() returns immediately while advancing the module's internal clock, letting you write fast, deterministic tests for code that normally relies on the real system clock. Recent updates improved compatibility with older Perls, added catching of localtime, and fixed interactions with tools like Devel::Cover.

Promise::XS provides a fast, XS-implemented promise API for Perl that gives you deferred objects, pre-resolved/rejected promises, and aggregators like all and race for composing asynchronous results. It focuses on speed and compatibility with existing Perl promise code rather than mirroring JavaScript promises exactly, so all and race take a list of promises rather than an arrayref and resolve/reject calls do not automatically unwrap promise values. Promises may carry multiple return values and the module warns about ambiguous cases, and it also implements finally with the ECMAScript-style semantics where the finalizer receives no arguments and can alter the outcome only by throwing or returning a rejected promise. You can use Promise::AsyncAwait for async/await syntax and opt in to proper event-loop semantics by integrating AnyEvent, IO::Async or Mojo::IOLoop, otherwise callbacks run immediately which can be useful for recursion. The module is stable, well tested, and suitable for production, includes optional memory-leak detection, and lets you subclass promise objects for custom behavior. Known caveats include possible issues with interpreter threads and problematic interaction with fork on Windows.

FFI::Raw is a small, low‑level Perl wrapper around libffi that lets you call functions in shared libraries directly from Perl without writing any C or XS code. You create a function object by naming the library and symbol and declaring the C return and argument types, or by giving a raw function pointer, then invoke it with call or by treating the object like a code reference. The module also provides helpers for pointers, memory buffers and Perl callbacks so you can pass and receive C strings, pointers and function pointers, and offers a set of built‑in C types including optional 64‑bit integers. Because it is deliberately low level you are expected to supply correct signatures and manage memory and types yourself, making it ideal when you need direct, procedural access to native libraries rather than a high‑level binding. Recent releases fixed a memory leak in callback objects and improved building by using pkgconfig and preferring a system libffi where available.

Mojolicious::Plugin::Fondation::OpenAPI generates an OpenAPI 3.0.3 specification and client-side validators from DBIx::Class sources for Fondation applications, and at runtime loads that spec via Mojolicious::Plugin::OpenAPI to perform request validation and to expose Swagger UI in development. It discovers your DBIx::Async backend, writes share/openapi.json and public/js/validators.js with optional overrides for per-column schema details and CRUD permission annotations, and honors plugin-declared exclusions so internal tables can be hidden from the public API. You can disable client-side validation with the no_validator_js option while keeping server-side validation, and x-auth overrides are translated into route-level permission and group checks at startup. Note the module requires Fondation::Model::DBIx::Async and newer Mojolicious::Plugin::OpenAPI/JSON::Validator, and there is a known packaging hiccup on Perl 5.40 that can be worked around by installing a prebuilt Net::IDN::Encode package on some systems. Recent releases improved regex/pattern handling for validators, added the no_validator_js toggle, and the latest 0.05 release fixes a regression in permission/group override behavior.

Mojolicious::Plugin::Fondation::CSRF adds straightforward Cross-Site Request Forgery protection to Fondation-based Mojolicious apps by leveraging Mojolicious' built-in session token and validation. It offers three easy ways to protect endpoints: an explicit per-route condition, automatic protection of POST/PUT/PATCH/DELETE routes generated from OpenAPI, and an optional global "around_dispatch" guard that blocks mutating requests except for configurable exemptions. Tokens live in the session and are accepted from a hidden form field or an X-CSRF-Token header, and the plugin ships a small csrf.js that reads a meta tag and auto-injects the header for fetch and XMLHttpRequest calls. Sessions must be enabled and the plugin is configurable (auto_protect on by default, plus an exemptions list). Recent 0.02 fixes ensure the CSRF route condition properly marks requests as denied instead of rendering directly and includes test dependency fixes.

Mojolicious::Plugin::Fondation::Auth::Token adds opt‑in Bearer personal access token authentication to Fondation applications by providing the fondation.bearer route condition so API endpoints can accept Bearer tokens or fall back to cookie sessions. Tokens are random strings whose SHA-256 hashes are stored in an api_tokens table and are meant to be created via CLI or fixtures rather than through an HTTP login endpoint. Routes that require fondation.bearer accept valid Bearer tokens or valid sessions, return 403 for invalid tokens and 401 for unauthenticated requests, and will reject Bearer headers with 403 on routes that do not opt in. The plugin works alongside other Fondation conditions such as fondation.perm and fondation.group so you can combine authentication and authorization checks. The 0.03 release updates the dependency on Fondation::Model::DBIx::Async to 0.06 and fixes the bearer condition to set a fondation.denied marker instead of rendering an error directly.

Mojolicious::Plugin::Fondation::Auth is a small plugin that adds ready-made login and logout routes and session-based authentication to Mojolicious applications using a DBIx::Class user table. It plugs Mojolicious::Plugin::Authentication into the Fondation user model and provides sensible defaults for model name, username and password columns, session timeout and session key while allowing you to swap the default DBIx provider for alternatives like LDAP or other custom providers. Password handling uses Argon2id via hooks in the supplied Result class so the plugin only needs to verify credentials, and it ships a customizable login template, English and French translations, and handy helpers such as current_user and is_user_authenticated for controllers and templates. The module is intended for apps built on the Fondation stack and depends on Fondation::User and Fondation::Model::DBIx::Async, and the recent 0.04 release fixes the authenticated-condition behavior to set a fondation.denied marker instead of rendering.

Mojolicious::Plugin::Fondation is a plugin manager for Mojolicious that helps you build modular web apps by composing reusable plugins that can supply routes, controllers, templates, and static assets. It loads plugins recursively according to declared dependencies, merges configuration with a clear priority order (direct overrides then app config then plugin defaults), and automatically shares each plugin's templates and public files with the application while giving the app's own templates top priority. After all plugins are loaded it runs configurable post-load actions such as registering templates, controller namespaces, and static paths, supports custom actions, and offers a finalization hook so plugins can defer work until everything is wired up. The module also provides helpers for rendering named UI zones and a set of route conditions for permissions and authentication, plus a registry you can inspect at runtime. If you are building a Mojolicious site from many modular components and want automatic discovery, configuration cascade, and coordinated initialization, Fondation is designed to simplify that work.

ClamAV::Clamd is a lightweight Perl client that talks to a running clamd daemon to offload virus scanning instead of linking libclamav, so you get a small dependency-free interface to a signature engine held in the daemon. It can scan raw bytes, files opened by your process, or file descriptors passed over a UNIX socket, and it supports both simple blocking calls and a nonblocking, event-loop friendly start_scan/step API for use inside web servers. Every scan returns a Verdict object with four explicit outcomes—clean, infected, unscannable, or error—so your code can safely accept only truly scanned files and distinguish failures or size/format limits from clean results. The module exposes utility methods like ping, version, stats and reload, reports transport type and error codes, and falls back to streaming over TCP where descriptor passing is not available such as on Windows. It includes guidance on clamd.conf settings needed for reliable reports and offers a C ABI so other XS code can call it, and if you prefer a pure-Perl client or a binding that links libclamav the distribution notes alternatives to consider.

PAGI is the formal spec for writing asynchronous web applications in Perl that can handle long-lived protocols like WebSocket and Server-Sent Events as well as normal HTTP requests. Rather than a single synchronous request/response call, a PAGI app is an async code reference that receives a scope describing the connection and two async callbacks, receive and send, so an application can handle any number of incoming and outgoing events with explicit backpressure. PAGI is designed as a modern, async successor and superset to PSGI and is split into three distributions so you can depend on the specification alone or install the reference server (PAGI::Server) and toolkit (PAGI::Tools) to run and build apps. The specification documents UTF-8 handling, lifecycle scopes (http, websocket, sse, lifespan), middleware patterns, and interoperability notes such as a PSGI adapter, and it cautions that the server and tools are still beta while the core spec is stable. A recent spec draft clarifies how application providers are normalized at runtime and centralizes the contract for send Futures so that success means the server has accepted the event for outbound processing rather than guaranteeing client receipt. If you want to build or migrate async Perl web apps that need streaming, push, or long-lived connections PAGI is the place to start.