CPANscan

Business::ISBN::Data is a data pack that supplies up‑to‑date ISBN range and publisher information to the Business::ISBN module so it can validate, parse, and interpret ISBNs correctly. You normally do not load it directly because Business::ISBN loads it for you, and it contains the RangeMessage.xml from the ISBN Agency plus a built‑in fallback dataset exposed in %Business::ISBN::country_data with a _source field showing the origin. If you need a newer or custom RangeMessage.xml you can point the module at it with the ISBN_RANGE_MESSAGE environment variable or place the file in the current directory, which avoids reinstalling the module. The distribution includes the XML and offers packaging tips for tools like PAR. The data are updated frequently and recent releases include fixes for ISBN‑13 handling, so make sure you use Business::ISBN 3.005 or later. The source is on GitHub and the code is redistributed under the Artistic License 2.0.

CallBackery is a Mojolicious-based application class that supplies the plumbing for building appliance-style web frontends and REST RPC endpoints. It handles configuration loading (defaulting to etc/callbackery.cfg with an environment override), exposes a pluggable database interface, and lets you declare security headers to harden browser clients. It also wires an RPC service namespace and controller and provides a starting document for built-in documentation links. Use it when you want a ready-made Mojolicious startup hook and common frontend infrastructure for device or appliance web UIs without reinventing configuration, database access, or basic security headers.

sshca is a small, command-line SSH Certificate Authority that helps you create a CA directory and issue SSH user and host certificates from public keys, making it easy to adopt short-lived certificate-based SSH authentication. The tool tracks issued certificates and serial numbers, supports adding principals and certificate options, can renew certificates using previous request data, list and filter certificates, and clean up expired certs. Configuration is handled with a YAML file and defaults to ed25519 keys and sensible validity windows, while environment variables and command-line flags let you override behavior. Storage is currently filesystem-based with planned support for database backends, and features like revocation and history are noted as future work. Overall it is a simple, practical choice for sysadmins who want a lightweight way to tighten SSH access without deploying a complex CA system.

Data::NestedKey is a compact, object-oriented Perl helper for reading and editing deeply nested hash and array structures using simple dot-separated path strings, with an optional CLI tool called dnk for piping JSON through a query. You wrap your data in a Data::NestedKey object and then use get, set, delete, and exists_key with paths like "a.b[2].c" to fetch values, check presence, or remove items, and negative array indices are supported for get, delete, and exists checks. The set method offers convenient prefixes for common operations, using "+key" to append or merge and "-key" to remove, but it does not accept array subscripts or operate directly on an array-rooted structure so array edits must be done by retrieving and modifying the Perl structure yourself. The object can be serialized back to JSON by default and also supports YAML, Data::Dumper, and Storable output, making it handy for tweaking configuration files or API responses when you need something simpler than a full jq dependency.

Apache::Solr is a high‑level Perl client for talking to an Apache Solr search server, letting you run searches, manage facets, highlights and suggestions, add or delete documents, commit or optimize indexes, and even invoke Solr’s Tika-based extraction to turn files into searchable documents; it supports both XML and JSON exchanges and provides a smart result object that preserves paging, timing and trace information while integrating with Log::Report for flexible logging and error handling. The module simplifies Solr parameter syntax for Perl, maps Perl booleans to Solr booleans, preserves request ordering, shares an LWP::UserAgent across instances, and offers configurable retry behavior for transient communication failures. It also exposes core management actions such as reload, status and unload, and warns about deprecated or removed Solr parameters to help maintain compatibility with specific server versions. Note that the field_key_simplify feature, which lets you use underscores instead of dots in nested field names, has a historically awkward default and is deprecated, and the recent 1.12 release fixes underscore handling while requiring Perl 5.16.1.

Cucumber::Messages is a Perl library that implements the Cucumber messages protocol and provides Perl classes for every message type used across the Cucumber ecosystem, together with NDJSON serialization and deserialization. It lets you build, inspect and emit Envelope-wrapped messages that Cucumber tools expect, for example converting Location, Attachment or TestCase objects to and from JSON with methods like to_json and Envelope->from_json. Use it when you need to integrate Perl test runners, formatters or reporters with other Cucumber components, handle attachments or externalized attachments, or consume/produce NDJSON message streams generated by the broader Cucumber toolchain. The module follows the shared cross-language message schema maintained by the Cucumber project and is kept in step with upstream protocol improvements.

Eshu is a fast, XS-powered tool that normalises leading whitespace in source files for C, Perl, XS, XML/HTML, CSS, JavaScript and POD by tracking nesting and re-emitting each line with correct indentation while leaving the line contents untouched. It understands language-specific constructs such as strings, comments, heredocs, regexes, template literals and embedded POD or script blocks so it produces sensible formatting rather than naive tabbing. You can call it from Perl code, use the included eshu command line for single files or whole trees with language detection, diffs, CI check mode and options for tabs or spaces and indent width, or install the supplied vim plugin for on‑the‑fly fixes. The engine is written in C for speed and runs as a single pass scanner, making it suitable for automating style fixes in projects and CI pipelines. Recent updates fixed incorrect indentation for certain preprocessor prototypes and expanded test coverage across languages to improve reliability.

Template::EmbeddedPerl is an embedded-Perl template engine that lets you place Perl code directly in template files or strings using familiar <% ... %> and <%= ... %> tags to generate HTML or other text formats. It provides features web developers expect such as optional automatic HTML escaping with raw/safe helpers, a cache for compiled templates, single-line interpolation, and helpers for partials, layouts and named content blocks, and it also adds an experimental typed-view system for composing nested view objects. Its distinctive advantage is correct block capture so you can embed map or sub blocks with template fragments naturally without awkward begin/end markers, making some patterns much cleaner than in Mojo::Template or Mason while remaining conceptually similar to those systems. Templates are compiled into a dedicated namespace to isolate symbols but this is not a security sandbox so only compile trusted templates. The recent 0.001016 release added smart line directives and declarative named template arguments, improved argument validation and diagnostics, and expanded partials, layout nesting and typed-view resolution to simplify building reusable view components. This module is powerful for projects that need flexible block capture or typed views but it is newer than some alternatives and the author notes there may still be undiscovered bugs, so choose it when its unique features matter.

Net::Curl::Promiser wraps libcurl's multi interface in a simple Promise-based API so you can do asynchronous HTTP and other transfers without wrestling with low-level polling, callbacks, or timers. It is a base class with ready-made subclasses for Mojolicious, AnyEvent, IO::Async and a plain select() loop, and you can add curl easy handles with add_handle to get back a Promise that resolves with the handle or rejects with an explicit error; you can also cancel or fail handles, pass through setopt and inspect active handles. The module detects common memory-leak patterns and warns during global destruction unless you disable that behavior. By default it uses Promise::ES6 except the Mojo subclass which uses Mojo::Promise and there is experimental Promise::XS support via an environment variable. Recent updates let the Mojo subclass run with a custom event loop and improve test reliability on Linux. This module is useful if you want a higher-level, promise-friendly way to drive libcurl from Perl and you are using one of the supported event systems or are willing to write a small subclass for another event framework.

Music::VoicePhrase is a lightweight generator for measured musical phrases that pairs rhythmic motifs with pitched voices so you can produce playable MIDI phrases for algorithmic composition or live performance. It combines scale and octave settings with a duration partitioner and a voice generator to produce lists of motifs and voices, and exposes convenient attributes such as base, scale, size, pool, weights, motif_num, patch and channel so you can shape pitch, rhythm and MIDI output. The module includes realtime-friendly state like a priority queue, index, current note, onsets and a gate parameter for controlling note length during rt-midi playback, and provides simple methods to rebuild motifs and voices or advance the playback index. If you need a small, configurable tool to create measured musical phrases programmatically or to drive MIDI synthesis in realtime, Music::VoicePhrase gives you the building blocks with sensible defaults and easy customization; recent updates improved the documentation and added the gate attribute for rt-midi use.

Sys::OsRelease reads the standard os-release file (typically /etc/os-release) and exposes the operating system identity and related metadata to Perl programs. It provides a singleton interface with auto-generated read-only accessors for the standard os-release fields and generic methods to list, query and retrieve any found attribute, determine a normalized platform string, and report where the file was located. The platform method recognizes common ID_LIKE values such as debian and fedora and can be customized when you initialize the singleton, making it useful for scripts, installers and container tooling that need to adapt to distribution, version or vendor differences. The module keeps minimal runtime prerequisites to remain suitable for constrained system environments. Recent releases add a Sys::OsRelease::Lite packaging to support older Perl versions prior to 5.22 for environments affected by Dist::Zilla dependency changes.

Game::TileMap::Pathfinding provides a fast Breadth-First Search pathfinder for Game::TileMap grids, using an XS core for performance and returning a Game::TileMap::Pathfinding::Result that lists the sequence of steps from start to goal, with undef returned when no route exists. It can optionally allow diagonal movement with simple collision checks and a diagonal step cost scaled by sqrt(2). Instances build a map of accessible tiles at construction and can be reused for many queries but do not track later changes in terrain, so you should recreate the pathfinder if accessibility changes. The module assumes all terrain types have equal movement cost, making it a solid choice for simple, high-performance grid pathfinding in games and simulations.

Dist::Zilla::PluginBundle::GEEKRUTH is a ready-made collection of Dist::Zilla plugins that reproduces the release workflow D. Ruth Holloway uses for her Perl distributions, so you can apply her conventions for metadata, testing, packaging, changelogs, git tagging and pushing, and other release chores with minimal setup. It wires together a long list of common plugins for generating META files, collecting contributors, running compile and extra tests, weaving POD, enforcing license and security policy, managing branches and tags, baking INI files, and auto-detecting prerequisites, while letting you tweak key options such as authority (default cpan:GEEKRUTH), builder (MakeMaker by default), development and release branch names (main and releases), upstream remote (origin), and a remove_plugin hook to drop parts you do not want. If you publish CPAN distributions and like a reproducible, curated release process, this bundle saves configuration time and enforces a consistent toolchain. The recent 4.0002 rebuild fixes incorrect META information caused by a buggy Codeberg plugin and follows the author’s move to Codeberg and an expanded security policy in the 4.0000 series.

Dist::Zilla::PluginBundle::Codeberg is a convenience bundle for Dist::Zilla that wires in Codeberg support so you can publish and maintain CPAN distributions hosted on Codeberg. It automatically adds the Codeberg::Meta and Codeberg::Update plugins to populate META fields like homepage, bugtracker and wiki and to create or update the remote repository, and it picks up your Codeberg credentials from git config or an optional ~/.codeberg file created by Config::Identity; you must create a personal access token with the api scope. Configuration options let you control which homepage or bug URL gets written, which git remote to inspect, whether to follow upstream forks, and the explicit repo name when needed. If you use Dist::Zilla for releasing modules and host your code on Codeberg this bundle saves manual metadata and repo setup work. Recent releases update the module to use the Forgejo/Codeberg API and remove the installer entry from dist.ini.

Mail::MIMEDefang is a Perl-based framework for building high-performance email filters that integrate with Sendmail via the Milter API. It lets system administrators and developers write custom Perl filters to block viruses and spam, tag or strip HTML, modify or replace attachments, add disclaimers, implement access controls, and quarantine messages. The distribution provides helper routines for logging, status tracking, percent-encoding, sending mail safely via sendmail, and for detecting and loading support for antivirus and anti-spam tools, so you can focus on policy rather than plumbing. If you run Sendmail and want flexible, scriptable message processing in Perl, MIMEDefang gives you a ready-made, production-quality framework to implement it.

DBIx::QuickDB is a lightweight helper for test and development workflows that quickly creates disposable database servers you can connect to from Perl, with built‑in support for PostgreSQL, MySQL/MariaDB, SQLite and optional DuckDB. You can define named, globally available databases at compile time or build instances on the fly at runtime, then call connect on the returned object; configuration allows you to pick drivers or a priority list, point at or create a data directory, auto-start and auto-stop the server, run bootstrap SQL, load schema files, control cleanup, and opt out of global caching. Environment variables such as QDB_TMPDIR and DB_VERBOSE let you control the temp directory location and server output, and the module also supports cloning and pooling of instances for faster test cycles. The project has seen steady reliability improvements around startup, shutdown, cloning and cross-platform behavior, and the most recent release improves Windows cleanup by retrying directory removal and explicitly disconnecting DBI handles before deleting data directories so leftover file locks no longer leave stale databases behind. If you need ephemeral, configurable database instances for automated tests or local development without managing full system servers, DBIx::QuickDB is a practical, well‑maintained choice.

Syntax::Highlight::Basic is a small pure-Perl library that provides straightforward syntax highlighting for source code, designed for embedding highlighted snippets in HTML or terminal output. It converts Vim syntax files into compact runtime data and uses those patterns to classify tokens into familiar Vim-compatible highlight groups. The module emits Pygments-compatible CSS class names, HTML with inline color styles, or ANSI terminal color sequences and already includes support for over 80 languages plus a CLI and a vim-syntax-to-shb converter for bringing your own definitions. You create an instance with optional custom syntax_dirs to load user syntax files, then call highlight($code, $language, \%opts) to produce output with options for format and wrapping, and you can customize colors and CSS classes to match your site or terminal theme. This initial 0.1.0 release is a handy, dependency-free choice when you need flexible, Perl-native highlighting that integrates with existing Vim syntax definitions.

OpenSearch::Client is an unofficial Perl client that lets Perl programs talk to OpenSearch clusters using a familiar Search::Elasticsearch-derived API. It provides the common tasks you expect from a search client such as connecting to a server, indexing and retrieving documents, running searches and using helpers like bulk and scroll, while remaining compatible with OpenSearch after the fork from Elasticsearch. The distribution is a maintained successor to the older Elasticsearch Perl client and includes recent practical improvements such as proxy configuration options for http and https, better support for testing against AWS Managed or proxied OpenSearch endpoints, and a few option name tweaks; full usage details are in the OpenSearch::Client::Manual.

Fondation::I18N is a translation plugin for Fondation applications that replaces the default identity fallback helpers with real dictionary-based translations. At startup it scans each plugin's share/translations/<lang>.json files, merges them into per-language lexicons stored on the app and exposed via a helper, and notes that when keys conflict the last file seen wins. On each request a before_dispatch hook picks the user language from a URL prefix or the Accept-Language header and caches the appropriate lexicon in the request stash so the l() helper can resolve strings with a single hash lookup. It also provides i18n_js to embed the current language lexicon into client JavaScript and registers an /i18n/<lang>.json endpoint for dynamic lookups, and it supports configuring a default language and which languages may appear in the URL.

Aion::Emitter is a lightweight event dispatcher for the Aion framework that triggers handlers based on the class of an event object, letting you attach behavior to domain objects without wiring callers to specific listeners. Listeners are discovered via the "#@listen" annotation and registered once in Aion’s container so each listener is represented by a single object, and emit accepts an optional key to target a specific variant of an event such as a particular controller or context. The module is aimed at making simple publish/subscribe flows easy to implement in an application that uses Aion annotations and environment config, and the latest release adds has_event and clear_event helpers to manage emitted event state. If you use Aion and prefer annotation-driven, class-based events with optional scoping, this module is a concise solution.

Mojolicious::Plugin::Fondation::User::UI::Bootstrap is a Mojolicious plugin that adds a ready-made Bootstrap 5 web interface for user management in Fondation-based applications. It provides templates, JavaScript assets including a DataTable initializer, and translations so you can list users in a paged, editable table and manage roles, groups and activation through modal dialogs. The plugin registers a GET /users route protected by the "fondation.perm => user_list" condition and relies on Fondation::User and Fondation::Layout::Bootstrap while delegating create, edit and delete operations to the Fondation::Action::REST handlers. Configuration is minimal with an optional page title and the distribution ships with the EP templates, client-side modules and i18n lexicons. This is the initial 0.01 release.

Mojolicious::Plugin::Fondation::OpenAPI is a plugin for Fondation/Mojolicious apps that generates an OpenAPI 3.0.3 specification and client-side validators from DBIx::Class sources discovered via a configured DBIx::Async backend, and then uses that spec at runtime to validate requests and add Swagger UI in development. You run it with the bundled CLI command openapi generate to produce share/openapi.json and public/js/validators.js which are meant to be committed with your app and used by your asset pipeline, and the plugin also maps schema and permission overrides from your configuration so you can control which columns are writeOnly or required and which endpoints need specific permissions or groups. It honors per-plugin declarations of tables to exclude so internal tables are not exposed, and at startup the generated spec is loaded by Mojolicious::Plugin::OpenAPI to enforce request validation and translate x-auth rules into route-level requires conditions. The module requires Fondation::Model::DBIx::Async and recent Mojolicious::Plugin::OpenAPI/JSON::Validator, which can hit a compilation issue on Perl 5.40 due to Net::IDN::Encode but distributions like Debian provide a packaged workaround. Recent 0.02 changes tighten naming and defaults and synchronize permission metadata with Model::DBIx::Async to make generated APIs and authorization rules more consistent.

Mojolicious::Plugin::Fondation::User is a ready-made user management component for Mojolicious apps built on the Fondation set of plugins. It creates a complete "users" table with Result and ResultSet classes, supplies a REST controller with standard CRUD endpoints under /api/user, and provides an optional Bootstrap-based HTML UI. Passwords are automatically hashed with Argon2 using Crypt::Passphrase and the hashing work is offloaded to the DBIx::Class::Async worker so your event loop stays responsive. The API never exposes the password field. Handy ResultSet helpers let you query active users, users created today, or the latest users, and built-in translations include English and French. Use this module when you want a plug-and-play user schema, endpoints, and UI integrated into the Fondation/OpenAPI workflow.

Mojolicious::Plugin::Fondation::Setup provides an interactive web-based setup wizard for Fondation applications that discovers available plugins on MetaCPAN, reads each plugin's declared setup metadata, and builds a step-by-step configuration workflow served at /setup. Users can pick which plugins to enable, complete per-plugin configuration screens whose fields are pre-filled from any existing config, and persist progress using a file-backed workflow so no database is required. When the wizard completes it writes a $moniker.conf file with the selected plugins and their settings and shows a confirmation page, and it will warn if Mojolicious::Plugin::Config is not enabled so you know to load the generated config. This plugin is a convenient way to assemble and configure Fondation plugins through a guided UI rather than hand-editing configuration.

Mojolicious::Plugin::Fondation::SessionStore is a Fondation plugin that replaces Mojolicious default signed-cookie sessions with server-side session storage using Mojolicious::Sessions::Store. Instead of keeping session data inside a readable cookie, the browser receives only an opaque session ID while the full session data lives on the server, which improves security, allows server-side revocation of sessions, and avoids cookie size limits. It uses a file backend by default that stores JSON files and can be configured with custom backends, a storage directory, cookie name, and expiration time. The standard Mojolicious "session" helper keeps working unchanged, so you can adopt server-side sessions without reworking existing session code.

Mojolicious::Sessions::Store provides server-side session storage for Mojolicious by replacing the default signed-cookie approach with a signed cookie that contains only a session ID while the actual session data lives in a backend such as the filesystem, Redis, or a database. It subclasses Mojolicious::Sessions so the usual session helper in controllers keeps working unchanged, making it a simple drop-in when you need to store larger or more sensitive session data, share sessions across processes, or enforce server-side expiration. Backends must implement load, save, and delete and a file-based backend is included in this initial 0.01 release, and common session attributes like cookie_name, default_expiration, samesite, and secure are supported for easy integration.

App::karr is the engine behind the karr command line tool that gives you a Git-native kanban board by storing board configuration, tasks and logs inside Git refs under refs/karr/*. Tasks are simple Markdown files with YAML frontmatter and commands materialize a temporary board view, serialize edits back into refs, and push them so your repository tree stays unchanged and you avoid ordinary file-level merge conflicts. The distribution is aimed at projects that want Git to remain the single source of truth and it ships both a CLI and lower-level Perl modules you can use for automation, plus Docker images for running karr without installing Perl locally. If you want to keep task state alongside your code and manage cards through Git operations, this tool is a good fit.

Unicode::UTF8 provides a small set of fast, standards-aware functions for encoding and decoding UTF-8 in Perl. It exposes decode_utf8 and encode_utf8 with optional callback fallbacks so you can customize how ill-formed sequences are handled, and by default replaces invalid input with the Unicode replacement character (U+FFFD). It also includes read_utf8 for reading and validating raw bytes from a filehandle without using a PerlIO encoding layer, slurp_utf8 to read and decode an entire file into memory, and valid_utf8 to test whether a byte string is well formed. The module preserves taintedness, emits clear warnings in the utf8 category, claims better diagnostics and much higher performance than Encode's UTF-8 implementation, and aims to be conformant with the Unicode standard.

Math::Float128 exposes C's quadmath __float128 type to Perl so you can create true 128-bit floating point objects, convert values from ints, floats or strings, and perform high-precision arithmetic with familiar overloaded operators. It supplies constructors and conversion helpers, stringification with configurable decimal precision, access to common quadmath constants, a large set of math library functions (trig, exp, log, gamma, etc.), and helpers to detect NaN, infinity or signed zero and to inspect the raw 128-bit bytes. Be aware that creating a Float128 from a Perl numeric versus a numeric string can produce different results unless your Perl uses __float128 for its native NV type, and some rounding-to-integer routines require Perl integer types large enough to hold C longs. The module includes workarounds for buggy quadmath functions on some older mingw-w64 compilers. If you need extended precision beyond IEEE double and have quadmath available, this module makes 128-bit floating math convenient from Perl.

Jacode4e is a pure-Perl character encoding converter tailored for Japanese enterprise and mainframe data, letting you convert strings in place between a wide range of legacy and modern encodings while preserving byte-level behavior when you need it, including a CP932X mode that brings JIS X 0213 support into CP932-compatible workflows. Its simple API is Jacode4e::convert(\$line, $OUTPUT_encoding, $INPUT_encoding, \%options), which returns a character count and accepts options to control fixed-record layouts, output shifting, SPACE and GETA replacement codes, override mappings, and reversible round-trip encoding. The module supports vendor and host encodings (CP932, CP932IBM, CP932NEC, CP00930, KEIS, JEF, JIPS, LetsJ), several UTF-8 variants, and fine-grained JIS/EUC/SJIS era handling, so it is useful when exchanging data with mainframes, preserving gaiji, or adding JIS X 0213 characters without a full system migration. The recent 2.13.6.23 release added era-aware 'sjis', 'euc', and 'jis' variants (1978/1983/1990/2000/2004), JIS X 0212 coverage as EUC code set 3 and ISO-2022-JP-1 output, many JIS output controls, and integrated the RoundTrip facility so reversible gaiji allocation is built into Jacode4e. If you work with legacy Japanese encodings or need deterministic, configurable conversions between PC, host, and JIS/Unicode repertoires, Jacode4e is likely relevant.