CPANscan

Sisimai is a Perl library that parses and normalizes email bounce messages into structured Perl objects or JSON so you can automatically extract who bounced, why, and when. It reads mailboxes, Maildir folders, individual eml files or raw input from STDIN and exposes a simple API where rise() returns decoded objects with fields like recipient, addresser, delivery status, reply code, reason, timestamp and origin, and dump() returns JSON. You can enable options to include successful deliveries or vacation autoresponses, add callback hooks to inspect or augment headers and per-message processing, and use helper methods to list supported decoding engines, map error text to a canonical reason, or get the module version. Sisimai is aimed at anyone who needs reliable, machine-readable bounce analysis for mail operations, reporting, or automated handling.

Perl::Critic::Policy::Performance::ProhibitRegexForSimpleSubstring is a Perl::Critic rule that detects uses of plain regular expression matches when a simple literal substring check would do and recommends using index() instead for better performance. It flags m// or bare // matches that contain only literal characters and no modifiers, while intentionally ignoring cases that require real regex features such as modifiers, character classes, quantifiers, anchors, groups, interpolation, alternation, substitutions or qr//; it also does not flag grouped expressions even if the group body is purely literal. The policy has no extra configuration, is part of the Perl-Critic-Policy-Performance-ProhibitRegexForSimpleSubstring distribution, and this 0.01 initial release was contributed by Dean Hamstead under the MIT license.

Encode::Wide is a lightweight Perl utility for turning non-ASCII text into plain 7-bit ASCII safe for HTML or XML by replacing wide characters with entity references. It provides two functions: wide_to_html emits named HTML entities when available and also escapes ampersands, angle brackets and quotes for safe embedding in HTML fragments, while wide_to_xml always emits hexadecimal numeric entities and folds en/em dashes to a simple hyphen so the output is valid XML. The functions accept Perl Unicode strings, raw UTF-8 byte strings or scalar references and by default normalize existing entities to avoid double-encoding. Optional flags let you preserve trusted markup (keep_hrefs) or keep apostrophes literal for JavaScript contexts (keep_apos for HTML only), and a complain callback lets you log unexpected characters. Be aware that keep_hrefs shifts trust to the caller and can create XSS risks if used on untrusted input, and the module is designed for text fragments not whole HTML documents. The recent 0.07 release tightened security by suppressing entity decode when keep_hrefs is set, fixed a ReDoS risk in the ampersand-handling regex, removed unsafe eval-style replacements, and added tests, command-line helper scripts and a few additional character mappings including the trade mark (TM) symbol.

App::GrepUtils is a tiny toolkit of command-line helpers that extend the familiar Unix grep for common small tasks, making grep workflows simpler and more convenient. The distribution provides three utilities: grep-nonblank to filter matches while skipping blank lines, grep-nonblank-clipboard to produce similar filtered output and place it on the system clipboard, and grep-terms to search for one or more terms with optional highlighting. If you often run quick ad-hoc text searches, copy matched results to the clipboard, or need multi-term highlighting without building complex grep pipelines, these lightweight wrappers save keystrokes and reduce boilerplate. The current release is 0.007 and newly adds grep-nonblank and grep-nonblank-clipboard.

Concierge::Users is a user-record manager that gives your app a simple CRUD API for user profiles and lets you choose how data is stored, with backends for SQLite, flat files, or per-user YAML so you can pick production-ready database storage or lightweight file formats. You run a one-time setup to define the storage location and the field schema, including built-in core and standard fields plus custom application fields, then load the generated config at runtime to register, fetch, update, list, and delete users. The module validates input with a variety of validator types and will either reject bad data or warn and drop invalid fields depending on configuration, and it supports skipping validation for bulk imports. It also auto-manages system timestamps, archives existing data on schema changes to avoid accidental loss, and integrates with the rest of the Concierge suite while remaining usable on its own.

Concierge::Sessions is a lightweight session manager for Perl that gives your application a simple, consistent service layer for creating, retrieving, deleting and cleaning up user sessions. It supports a production-ready SQLite backend via DBI and a file-based JSON backend for testing and small deployments, stores any JSON-serializable data, enforces one active session per user, and implements sliding-window expiration plus optional indefinite sessions for application-wide state. The API returns uniform hashrefs so callers can check success and get either a session object or a descriptive error message, and session objects expose methods to read, modify and save data which extends the timeout. The module is written for modern Perl and emphasizes performance and predictable behavior, and the latest release fixes a crash during program shutdown by guarding the SQLite handle in DESTROY.

Concierge::Auth is a tiny factory that loads and returns a live authentication backend instance when you give it a fully qualified class name. You call Concierge::Auth->new with backend => 'Concierge::Auth::Pwd' (or another backend class) and any other parameters are passed straight to that backend's constructor, and the returned object implements the standard auth contract so you call authenticate, is_id_known, enroll, change_credentials and revoke directly. The factory does no name guessing, supplies no defaults, and dynamically requires only the backend you name so unused auth code is never loaded. The distribution also provides Concierge::Auth::Base, which defines the backend contract and convenient generators for tokens and IDs, and Concierge::Auth::Pwd, a built-in file-backed password backend. Note that in v0.5.0 the module was redesigned from a monolithic password manager into this thin factory model, so existing code must now use a concrete backend class, and the recent v0.5.1 release made small internal cleanups and expanded test coverage.

Net::Blossom::Server::Backend::Postgres is a PostgreSQL-backed storage plugin for Net::Blossom::Server that keeps blob metadata and payloads in Postgres via DBI and DBD::Pg. It stores actual blob bytes as PostgreSQL large objects and provides Storage-compatible operations for starting uploads, committing validated blobs, streaming downloads (including ranged reads), peeking metadata, deleting owners or blobs, and listing a user’s descriptors. Downloads are streamed from the database so blob bodies do not have to be loaded into Perl memory, and uploads are imported transactionally after validation; each active download uses a cloned DBI connection and a read transaction so you must provision enough Postgres connections for your concurrency. The backend uses advisory locks to serialize uploads and deletes for the same hash, can deploy and migrate its schema automatically, and accepts either a DSN or an existing DBI handle at construction. This module is ideal when you want tight integration of blob bytes and metadata inside Postgres, though very large public media services may prefer storing blob data outside the metadata database.

Net::Blossom::Server::Backend::SQLite is a SQLite-backed storage implementation for Net::Blossom::Server that stores blob bytes and metadata in a local SQLite database via DBI and DBD::SQLite. It implements the server Storage contract and gives you the tools to begin uploads, commit validated blob metadata, fetch whole blobs or byte ranges, read descriptors, delete blobs or owners, and list blobs for a given key while exposing the DBI handle and a configurable public base URL. The module coordinates separate metadata and blob store components on one SQLite handle and accepts either a file path or an existing DBI connection. Calling deploy_schema will create the required tables and perform an automatic migration from older schemas, so you should back up before upgrading. This backend is best for self contained single node deployments, local development, and tests and can be suitable in production when blob sizes, traffic, and write concurrency are limited, but very large media archives or high traffic public servers will generally want Postgres or an external blob store.

DBIx::QuickORM is a DSL-driven builder for creating composable, reusable ORMs in Perl that lets you declare servers, databases, schemas, tables, columns, links, types, row classes and plugins in a concise, structured way. It supports introspection via an autofill mode so you can generate schema and row classes from an existing database, offers pluggable SQL dialects and DBI drivers for PostgreSQL, MySQL/MariaDB, SQLite and DuckDB, and includes features for controlling identity, defaults, lazy/omitted columns and volatile/generated columns. The builder supports variants so you can maintain multiple backend-specific flavors from the same definition and provides hooks for custom naming, plugins and custom type inflation/deflation. Full usage and worked examples start with DBIx::QuickORM::Manual::QuickStart. Be aware this project is still in early development and the API and behavior may change as it stabilizes.

Net::Blossom::Server is the framework‑neutral server core for the Blossom protocol that implements the HTTP operations you need to store, retrieve, list, mirror, and delete content while delegating actual storage to pluggable backends. Gateway adapters such as PSGI or PAGI translate native requests into Net::Blossom::Server::Request objects and this module handles PUT/GET/HEAD/DELETE and list endpoints, streams uploads with SHA‑256 calculation and optional size limits, supports a configurable mirror fetcher for origin downloads, and returns standardized JSON blob descriptors for clients. It requires a storage implementation that follows the Net::Blossom::Server::Storage contract and provides options for chunking, clocking, max upload and list limits, and pass-through uploader authorization so framework adapters can manage authentication. Recent updates split storage contracts into distinct metadata-store and blob-store component interfaces and moved object construction to Class::Tiny to simplify backend implementations and testing.

Concierge is a Perl service-layer orchestrator that wraps authentication, session handling, and user record storage behind a single, consistent API so applications never talk to those components directly. It coordinates an Argon2-based Auth, flexible Sessions (SQLite, file, or in-memory) and Users stores (SQLite, YAML, CSV/TSV) and provides simple lifecycle operations for visitors, guest sessions, and logged-in users while tracking active clients with persistent user_key tokens stored in a desk directory. Every method returns a predictable success/message hashref and user lifecycle calls return Concierge::Desk::User objects so your code can restore, upgrade, or log out users and transfer guest session data to authenticated accounts. The suite enforces a single-session-per-user policy, supports backend substitution for custom auth or storage implementations, and is extensible with additional components. In the recent v0.10.0 release the internal base scaffold was removed and a component method promotion feature was added so you can expose a curated subset of a component's methods directly on the Concierge object for convenience while retaining the full component API via its accessor.

Task::BeLike::GEEKRUTH is a CPAN task bundle that installs the collection of Perl tools and libraries Ruth Holloway uses to develop and release software. It gathers development infrastructure like git, cpanminus, perlbrew, Dist::Zilla and its plugins, Perl::Tidy and Perl::Critic, a PostgreSQL and DBIx::Class based database stack, and web app components such as Dancer2 and its plugins, Starman, JSON and templating helpers, plus common utility modules like Moo, Try::Tiny and YAML::Tiny. The goal is to recreate the author’s workstation and workflow quickly so you can follow her conventions for building, testing and releasing Perl applications. This is aimed at developers who want a ready-made dev toolchain rather than at end users, and the POD even lists Debian packages the author installs first to prepare a fresh machine.

Dancer2::Plugin::QuickORM is a small plugin that injects QuickORM-style convenience into Dancer2 web apps, making it easier to use QuickORM models inside route handlers without repetitive setup code. If you use the Dancer2 framework and want to access database-backed models with terse, familiar QuickORM syntax, this module wires that syntax into your app so you can write CRUD and model access more quickly and with less boilerplate. It is an early, lightweight release that expects Dancer2 and QuickORM to be available and is aimed at developers who want straightforward integration rather than a heavy, feature-rich ORM bridge.

Dancer2::Plugin::ContentCache is a Dancer2 plugin that lets your app cache rendered HTML or JSON responses and optionally redirect users to a cached GET URL after a POST to avoid double-posts and timeout-related resubmissions. It stores content through a pluggable driver interface with a bundled DBIx::Class driver by default so you can use the storage backend you prefer. The plugin provides simple route-level helpers like cache_and_redirect and cache_and_send plus utilities to set, retrieve and clean up cache entries, and it supports optional cache aging with a configurable default lifetime and a built-in retrieval route that can require login. Cache entries are immutable once created and cache aging requires driver support for creation and expiry timestamps. This is the initial 1.0.0 release and includes the DBIC/DBIx::Class driver.

App::SeismicUnixGui is a Perl/Tk graphical front end for the Seismic Unix toolkit that lets you pick and configure parameters for SU modules through windows and dialogs instead of editing command lines. It is aimed at users who process seismic reflection or signal data with Seismic Unix and prefer a visual way to assemble processing steps, inspect options, and reduce manual command-line editing. The package is in beta and uses Perl/Tk, a mature and freely available GUI framework, so it is a good fit if you already use Seismic Unix and want a simpler, more interactive way to set up processing tasks.

Log::Any::Adapter::JSONLines is a lightweight Log::Any adapter that writes each log entry as a single JSON object on its own line, following the JSON Lines format, and it defaults to printing to STDOUT but can write to any file or filehandle you provide. It works with Log::Any structured logging and context data and lets you tweak records with before and proxy hooks so you can add metadata, mask sensitive fields or insert location info just before serialization. You can set the log level, output encoding, and optionally enable alphabetical key sorting for predictable output, and the adapter supports common use patterns where a message string and a data hash become a single JSON object. Be aware of a couple of limitations: passing more than two mixed arguments produces a messages array instead of a single message and formatted logging routines like debugf are not supported due to how Log::Any handles sprintf. This is an early release, version 0.001, and the module is still under development.

Travel::Status::DE::DBRIS is an unofficial Perl client for Deutsche Bahn's bahn.de departure monitor and train information APIs that makes it easy to fetch station departure boards, search for stations by name or coordinates, retrieve journey details, and request carriage formation data. It supports both blocking and non-blocking workflows so you can use it in simple scripts or integrate it into evented applications via promises and Mojo::UserAgent, and it offers useful options such as caching, an optional failure cache, filtering by mode of transit, limiting intermediate stops, and loading prepared JSON for testing. The module exposes high-level result objects for stations, journeys and formations and includes a developer_mode to print raw requests and responses for debugging. Be aware that this is a work in progress and that Deutsche Bahn’s recent Akamai WAF behavior can make frequent requests risky, so the module provides randomized headers and caching hooks to reduce that risk and a note of caution about caching failed requests permanently. The latest release updates rolling stock models and fixes mis-detected models for non-German carriages, improving carriage formation accuracy.

Net::Blossom::Server::Backend::Filesystem provides a filesystem-backed storage layer for Net::Blossom::Server that stores blob bytes as ordinary files while letting you use any compatible metadata store implementation, so you get simple, local file storage with pluggable metadata. It stages uploads under a configurable root, publishes immutable generation-specific keys via non-overwriting hard links, shards paths by the first four hex characters of the SHA-256 hash, and streams downloads from filehandles to avoid loading whole blobs into memory. The constructor requires a metadata_store and a base_url and accepts either a root directory for the default file-backed blob store or a custom blob_store object, and it supports custom filename-generation and a post-commit cleanup error handler. The design targets durability and safe concurrent writers on a POSIX filesystem that supports hard links and directory synchronization and has been tested on local Linux filesystems, so be cautious on multi-node filesystems such as NFS or CephFS. Use this module when you need a straightforward, efficient on-disk blob store with separate metadata management and streaming I/O.

Catalyst::Plugin::MCP adds a Model Context Protocol (MCP) server to a Catalyst application by levering Catalyst::Plugin::JSONRPC::Server and exposing a simple seam for registering per-request provider objects that supply tools, resources or prompts and for dispatching MCP requests. You call mcp_register_provider during an action to add providers for the current request and then call mcp_dispatch to build a fresh, request-local MCP engine, route the verb and write the response, which avoids cross-request handler leakage and concurrency hazards. The plugin reads and size-checks the request body for you unless you supply a raw JSON body, supports configurable protocol versions and advertised server_info, and requires that the application load Catalyst::Plugin::JSONRPC::Server first. It intentionally ships no authentication or Origin validation so you must protect the endpoint and validate Origin before dispatching. Recent releases tighten compatibility with the underlying JSONRPC server and now require Catalyst::Plugin::JSONRPC::Server 0.003 so mcp_dispatch can return the correct HTTP 202 empty-status for notification-only requests.

AWS::Lambda provides an easy path to run Perl code on AWS Lambda by supplying a custom runtime plus prebuilt Lambda layers, zip archives and container images so you can drop in a handler.pl or build a Docker image and deploy quickly. It bundles helpers to find the correct layer ARNs, preinstalls common modules such as JSON and AWS::XRay, supports streaming responses and X‑Ray tracing, and offers optional Paws layers for calling AWS APIs from your function. The distribution includes tooling for local testing with Docker and guidance for creating custom module layers, follows the Perl community policy for supported Perl releases, and targets Amazon Linux 2023 while marking older AL and AL2 layers as legacy and no longer maintained. The latest 0.10.0 release adds support for Perl 5.44.0 and performs a few dependency updates while temporarily removing two regions for safety.

Catalyst::Plugin::OAuth2::ResourceServer is a Catalyst plugin that makes it simple to protect routes with OAuth 2.1 bearer JWTs by verifying access tokens, checking audience and issuer, and exposing token claims, scopes, and an app-resolved identity to your controllers. It handles extraction of Bearer tokens, performs cryptographic verification with a configured signing key, provides helpers to require authentication and specific scopes, and emits RFC 6750 WWW-Authenticate challenges plus an RFC 9728 protected-resource metadata document served with Cache-Control no-store. Configuration covers signing_key, resource and issuer validation, allowed JWT algorithms, clock skew leeway, advertised authorization servers and scopes, and an optional metadata URL which is otherwise derived from the resource URI when possible. You can implement oauth_resolve_subject to map the token subject to an application identity which is important for enforcing revocation or account deactivation, and the actual verification engine lives in a separate Server module so this plugin remains a thin Catalyst integration layer. An examples directory provides a runnable demo to get you started.

Catalyst::Plugin::OAuth2::AuthorizationServer adds a ready-made OAuth 2.1 authorization server (MCP profile) to a Catalyst application, providing authorization_code with PKCE-S256 for public clients, refresh_token rotation, dynamic client registration and standard AS metadata endpoints so you can expose a discovery document, register clients and issue tokens from your app. It issues signed JWT access tokens using symmetric HMAC (HS256/HS384/HS512) only, so it is intended for single-deployment setups where the Authorization Server and Resource Server share a secret and not for scenarios where third parties must verify tokens via JWKS. The plugin wires protocol logic into Catalyst and expects your app to handle user authentication and consent via an oauth_authenticate hook that calls back to oauth_issue_code; an optional oauth_dcr_allow_registration hook can rate-limit dynamic registration. Note the important operational limits: refresh-token reuse revokes the entire token family and does not retroactively invalidate already-issued stateless access tokens so you should keep access_ttl short, there is no built-in revocation endpoint or denylist, and Store implementors must follow the module's Role::Store contract. Recent updates mostly clean up examples and documentation to use generic example scopes; earlier changes introduced stricter PKCE verifier validation, signing_key length checks and an updated Store contract to support refresh-token family revocation.

Catalyst::Plugin::JSONRPC::Server is a small plugin that adds JSON-RPC 2.0 request handling to Catalyst apps by giving your context two helpers, jsonrpc_register and jsonrpc_dispatch, so you can register method handlers inside a request and have the plugin parse, route and respond to JSON-RPC calls over HTTP. It builds a fresh dispatcher per request so handlers and any closures do not leak between requests, and you can tune behavior with configuration like max_body_bytes (default 10 MiB) or supply your own dispatcher to change limits such as max_batch (default 1000). Handlers receive the JSON-RPC params and return results or throw a Catalyst::Plugin::JSONRPC::Server::Error to signal JSON-RPC errors while a plain die becomes a guarded internal error. Dispatch writes the appropriate HTTP response, returning the response payload or undef for notifications, and there is a jsonrpc_dispatch_with method if you need to reuse or preconfigure a dispatcher. The distribution includes a runnable example app and client so you can see echo and sum handlers in action.

Arango::Tango is a lightweight Perl client that gives you a straightforward mapping to the ArangoDB REST API so you can create and manage servers, databases, collections and documents from Perl without a heavy dependency. It exposes a simple top-level object that returns Database and Collection objects and covers common tasks such as creating and deleting databases and collections, managing users and permissions, running queries and cursors, importing documents in bulk, and inspecting server and cluster metadata and statistics. The distribution focuses on practical, easy to use methods rather than covering every advanced feature and it validates options with JSON::Schema::Fit which may silently adjust inputs, and it will die on errors so callers should use eval or a try/catch wrapper. Recent work refactored error behavior and added a create_index method to create hash, skiplist, persistent and geo indexes. The module is intentionally minimalist and evolving so contributions and patches are welcome.

RPi::OLED::SSD1306::128_64 is a Perl driver for 128x64 SSD1306-based monochrome OLED panels on the Raspberry Pi that makes it easy to draw text and simple graphics from Perl. It uses a small bundled C layer and wiringPi to mirror the display's 1KB framebuffer on the Pi and push updates over I2C, and exposes simple methods for text, characters, pixels, lines, rectangles, display refresh and clearing so you can build and then push a whole frame. The module defaults to I2C address 0x3C, requires wiringPi (3.18+), supports dimming and inversion, and is implemented as a singleton so repeated new() calls return the same live display object. Recent improvements include a flicker-free clear_buffer/display workflow and a much faster display() that streams the full framebuffer in one I2C transaction for noticeably quicker refreshes.

BarefootJS::Backend::Xslate is a rendering backend that lets the BarefootJS runtime render Kolon (.tx) templates using Text::Xslate, without tying you to any web framework. It can take a prebuilt Text::Xslate instance or build one from a list of template paths and options, and it configures Xslate for HTML auto-escaping while providing a mark_raw helper for emitting raw markup. Templates compiled by the companion @barefootjs/xslate adapter call runtime helpers as methods on a bound bf object, so the backend needs no special function map and works equally well inside PSGI/Plack apps or in standalone scripts. The module exposes a small set of runtime operations such as render_named, encode_json (customizable), materialize, and mark_raw, making it a lightweight bridge between BarefootJS templates and Text::Xslate rendering.

Mojolicious::Plugin::BarefootJS makes it easy to use the BarefootJS server runtime inside a Mojolicious app by registering a bf controller helper that lazily creates a per-request BarefootJS instance backed by BarefootJS::Backend::Mojo. The helper lets you render compiled marked templates as native Mojolicious templates so you can integrate BarefootJS rendering into your controllers and views with minimal configuration. This plugin is useful for Mojolicious developers who want to adopt BarefootJS templating and runtime behavior; projects running on other PSGI hosts can use BarefootJS::Backend::Xslate for a comparable integration without Mojolicious.

BarefootJS is a lightweight server-side runtime that supports templates compiled from JSX/TSX into BarefootJS "marked" templates and accompanying client JavaScript. It supplies the runtime helpers those compiled templates call at render time, for tasks like JSON marshalling, marking raw strings, materializing JSX children, spreading attributes, and invoking named sub-templates. The design deliberately avoids locking you into a specific template engine or web framework by delegating engine- and framework-specific behavior to pluggable backends such as BarefootJS::Backend::Xslate for Text::Xslate or Mojolicious::Plugin::BarefootJS for Mojolicious, so the core itself only pulls in Perl core modules unless a chosen backend requires more. If you need to render JSX-style templates from Perl in a PSGI/Plack or Mojolicious app and want a minimal, backend-agnostic runtime, BarefootJS is a good fit and it is actively maintained under the MIT license.

Lingua::JA::Moji is a comprehensive Perl toolkit for converting among the many written forms of Japanese text and related encodings, including romanized Japanese, hiragana, katakana, halfwidth and fullwidth kana, circled forms, braille, Japanese morse, wide ASCII, hentaigana, and a range of kanji variants such as pre- and post‑1949 forms and bracketed/circled kanji, and it also offers experimental mappings to Cyrillic and Hangul; it provides validators and normalizers for romaji with multiple strictness levels and supports several romanization styles like Hepburn and Kunrei, while expecting Unicode (UTF-8) input and loading conversion data on demand to avoid heavy memory use. The module does not attempt to convert kanji into kana readings or perform morphological segmentation for accurate braille, and some experimental conversions warn of limited correctness. A small but useful recent change in version 0.62 makes is_romaji_semistrict return a canonical romaji form rather than a simple true value when the input is accepted.