CPANscan

JSON::Schema::Modern is a Perl JSON Schema evaluator and validator that implements the full specification up through Draft 2020-12, letting you validate Perl data structures or JSON strings against reusable schema documents and receive a rich Result object describing errors, annotations and defaults. It supports older drafts as well, bundles the official metaschemas, and offers configurable behavior such as short-circuiting, format validation, stringy-numbers handling, content media-type and encoding support, custom format validators and vocabularies, callback hooks, and caching helpers for faster startup. You add schema documents to the evaluator and then call evaluate or evaluate_json_string to run validation, and you can extend or override format, encoding and media-type handling to suit your application. A few convenience features are not implemented yet, for example automatic loading of schema documents from disk or the network, and some format checks require optional CPAN modules. Also take care with untrusted schemas because embedded regular expressions and large-number operations can be expensive or unsafe.

Config::Model is a mature Perl framework for describing, validating, migrating and interactively editing application configuration through a declarative model. You express your configuration schema as Perl data structures and the framework builds a validation engine, read/write backends and multiple user interfaces so you can inspect, edit and upgrade config safely from code or with the cme helper command. It supports common backends such as INI and Perl data files and can integrate Augeas for complex formats, and it can expose configuration as a virtual filesystem or drive GUI, curses or terminal UIs from the same model. The module is designed for maintainable, testable configuration tooling that separates model from processing logic, makes upgrades and audits easier and provides hooks for migration and automatic fixes. Recent releases include bug fixes around warped nodes and value handling and a change to use Filesys::Fuse3 for the Fuse UI.

Object::Iterate provides simple iterator-style control structures for objects that can yield a next element but cannot be turned into a list. It supplies iterate, igrep and imap which call an optional __init__, then loop while __more__ is true and fetch each element with __next__, setting $_ for the block just like foreach, and call an optional __final__ when done. Use it to apply foreach, grep or map semantics to streaming or virtual collections that would be impractical to materialize as an array. The expected method names can be changed via package variables ($Object::Iterate::Next, $More, $Init, $Final) but those names apply globally and AUTOLOADed methods cannot be detected, so you may need to localise the variables or provide real methods on your objects. The module is on GitHub and is released under the Artistic License 2.0.

Net::Async::WebSearch is an IO::Async-based search aggregator that fans a single query out to multiple pluggable web-search providers and merges their answers into a unified, deduplicated result set. It supports three modes: collect to wait for every provider and rank results with Reciprocal Rank Fusion, stream to emit unique results as each provider finishes, and race to return the first successful provider. You register provider instances (built-ins include DuckDuckGo, SearxNG, Serper, Brave, Google CSE, Yandex, Reddit and OAuth variants) and can stack multiple instances, tag them, and select or exclude them per call with simple selectors; per-provider option overrides and a shared Net::Async::HTTP client make configuration flexible. An optional fetch feature can GET top result pages and attach their bodies with configurable concurrency and timeouts, and every result is normalized with provenance and per-provider error reporting. The recent 0.002 release mainly tightens and clarifies the POD examples around provider instantiation and registration.

Mojo::DOM::Role::Style is a lightweight role that adds a convenient style() method to Mojo::DOM elements for reading and manipulating an element's inline CSS. Calling style with no arguments returns a Style::Value object that stringifies to the CSS text and can be used like a hash to read individual properties, while calling it with a single property name returns that property's value. You can replace the whole style by passing a raw CSS string or an even length list of property/value pairs, merge new properties by passing a hash reference, or remove the style attribute by passing undef. Setter calls return the element for method chaining which makes it handy in DOM transformations, scraping, or server side HTML generation. If you work with Mojo::DOM and need simple programmatic control over inline styles this role makes those operations concise and predictable.

SVGPDF is a Perl module that converts SVG images into PDF XObjects you can drop into PDF::API2 or PDF::Builder documents, producing one or more reusable graphics objects along with metadata about their viewBox and sizes. It accepts SVG from a filename, filehandle or string and understands a wide range of common SVG elements and style attributes so it works well for charts, MathJax output, QR codes, and other tool-generated SVGs. You can control page size, add a debug grid, combine multiple SVGs into a single object, and supply a font-handler callback to map SVG font-family/style requests to PDF fonts or rely on built-in corefont aliases, but note that corefonts only cover Latin-1 characters. The module documents coordinate and unit handling and returns an array of hashes describing each XObject for easy placement in a PDF page. Some SVG features are only partially implemented, such as percentage units, embedded SVG and preserveAspectRatio, and other features like gradients, transparency, clipping, masking and text-on-path are not supported. Recent updates improved color parsing and handling of global color styles for text and tspan elements and fixed platform-specific test issues, making color handling and text rendering more robust.

Net::Async::Gearman is a small Perl adaptor that integrates the Gearman protocol with the IO::Async event loop, providing an async-friendly wrapper around Protocol::Gearman. It is a low-level building block rather than a user-facing API, so you should normally use the higher-level Net::Async::Gearman::Client; the module mainly exposes an async connect method that takes the same arguments as IO::Async::Handle and defaults to Gearman’s usual port 4730.

Module::Extract::Use scans Perl source files without running them to identify modules that are explicitly loaded with use or require and to detect inheritance declared via parent or base. It offers simple calls to return either a plain list of namespaces or detailed records that include any requested version, the import list, whether the entry looks like a pragma, and a flag showing if the module came from parent/base rather than a direct use. Because it uses static analysis it will not find modules loaded dynamically at runtime, for example via eval or variable requires. The API is lightweight: instantiate, call get_modules or get_modules_with_details, and check error for parse problems. This makes it handy for audits, dependency discovery, and tooling that needs to know the explicit, statically declared dependencies of Perl code.

Dist::Zilla::PluginBundle::OYOULE is a small, opinionated bundle for Dist::Zilla that encodes Oliver Youle's preferred packaging and release setup so you can drop a single [@OYOULE] stanza into dist.ini and get sensible defaults. It requires you to name the distribution and provides switches to publish to the public CPAN or a private DarkPAN, to point repository metadata at GitHub or a private git host, and to copy a generated license file back into the distribution root. If you build dists the same way as the author this saves repetitive configuration and keeps releases consistent, and recent releases added automatic package-version handling via Dist::Zilla::Plugin::OurPkgVersion and bumped the ExtUtils::MakeMaker requirement while standardizing the license to Perl 5.

Dist::Zilla::Plugin::UploadToDarkPAN is a small Dist::Zilla extension that makes it easy to publish your Perl distribution to a private CPAN mirror, often called a DarkPAN. It hooks into Dist::Zilla’s release command and reuses the standard UploadToCPAN behavior while letting you specify a darkpan_uri for your internal upload endpoint. Configuration can live in dist.ini, ~/.dzil/config.ini, or ~/.pause and the plugin will prompt you for the darkpan URI if it is not provided. Use this plugin if you manage or publish to an internal CPAN-like server and want a drop-in way to release from Dist::Zilla to that private repository.

mb::JSON is a small, dependency-free JSON encoder/decoder for Perl that correctly handles UTF-8 multibyte strings and runs on very old Perls (5.005_03 and later), making it useful when JSON::XS or JSON::PP are unavailable. It offers simple symmetric APIs decode/parse to turn JSON text into Perl structures and encode/stringify to produce UTF-8 JSON text from Perl data, and it provides singleton objects mb::JSON::true and mb::JSON::false so JSON booleans are represented unambiguously. encode sorts hash keys for deterministic output and leaves UTF-8 bytes as-is while decode converts \uXXXX escapes into UTF-8. The module has a few cautions to know about: it does not support surrogate-pair decoding for \u sequences, it will not detect circular references during encoding, and non-array/non-hash references are stringified rather than causing errors. Recent 0.06 work added stringify() as an alias for encode() and formalized parse() as an alias for decode() to mirror JavaScript’s JSON.stringify/parse.

Jacode4e::RoundTrip is a Perl module for reliably converting Japanese text between a wide range of legacy and modern encodings while preserving JIS X 0213 characters for round-trip workflows on enterprise systems. It targets mainframe and vendor-specific encodings such as CP932X, CP00930, KEIS78/83/90, JEF, JIPS, LetsJ and variants of UTF‑8 including an internal UTF‑8-SPUA-JP form, and provides options to control how single/double-byte regions are detected, whether SI/SO shifting codes are emitted, and what placeholder (GETA) or space bytes to use for unmapped characters. The module is designed to let you exchange JIS X 0213 data between systems and import it back without losing privately mapped characters by using user-defined areas and carefully chosen mappings, but note that true round-trip fidelity requires using the same version of Jacode4e::RoundTrip on both sides of the conversion. Recent updates added extensive multilingual cheatsheets and tests plus a SECURITY.md, reflecting ongoing maintenance and better documentation and test coverage.

Jacode4e is a Perl module for converting text between a broad set of Japanese encodings used in enterprise environments, from Microsoft CP932 and its IBM and NEC variants to Shift_JIS-2004, legacy vendor sets like KEIS, JEF, JIPS and LetsJ, plus UTF-8 variants and the module's own CP932X and UTF-8-SPUA-JP. It operates in place via Jacode4e::convert, which takes a scalar reference and explicit input and output encoding names and returns a character count, and it accepts options to describe input layout when SI/SO shift codes are not present, to emit output shifting codes, and to customize space, geta replacement and override mappings for unmapped or private characters. The module is designed to help bridge JIS X 0213 compatibility while keeping existing CP932-based systems, databases and applications usable without wholesale changes. If you require guaranteed round trip preservation there is a companion Jacode4e::RoundTrip module. Recent releases include mapping fixes and added support for utf8.1 and extra CP932 variants and an OVERRIDE_MAPPING option to handle special cases.

WWW::Firecrawl is a Perl client for the Firecrawl v2 web crawling and scraping API that is built for self-hosted deployments but also works with the cloud service. It exposes every API endpoint in three forms so you can either get an HTTP::Request, parse an HTTP::Response, or call a convenience method that uses LWP::UserAgent for synchronous requests. The module centralizes configuration such as base URL, API key, retry policy, and a pluggable failure predicate so you can tune how target-level failures are classified and when retries happen. Errors are raised as WWW::Firecrawl::Error objects with distinct types for transport, API, job, scrape, and page failures which makes programmatic handling straightforward. It covers the full v2 surface including scrape, crawl, mapping, search, batch scraping, extraction, agent/browser controls, and monitoring endpoints, and provides helpers like scrape_many and retry_failed_pages for partial-success workflows. If you need to drive Firecrawl from Perl and want both simple synchronous helpers and raw request/response building for async integration, this module gives a tidy, configurable binding.

Net::Async::Firecrawl is an IO::Async-friendly client for the Firecrawl v2 API that wraps WWW::Firecrawl request builders and parsers and dispatches traffic over Net::Async::HTTP while returning Future objects for non-blocking use. It exposes every WWW::Firecrawl endpoint as an async method and adds high-level flow helpers that automate common patterns like starting a crawl or batch job, polling for completion, walking paginated results, classifying pages into success or failure, and collecting or retrying failed pages. You can use it to run single scrapes, concurrent per-URL scrapes, batch scrapes, structured extraction and agent jobs, and to wait for final status with convenient helpers such as crawl_and_collect, batch_scrape_and_wait, extract_and_wait, scrape_many and retry_failed_pages. Constructor options let you supply base_url, api_key or an existing WWW::Firecrawl or Net::Async::HTTP instance and control poll intervals, delay behavior and retry/classification policies. Errors are surfaced as WWW::Firecrawl::Error objects and categorized (transport, api, job, scrape, page) so you can handle transient retries and distinct failure types cleanly. If you build IO::Async applications that need to drive Firecrawl jobs and gather results asynchronously, this module provides a ready-made, Future-based integration.

Markdown::ODF is a compact Perl utility that converts Markdown into OpenDocument text documents and returns an editable ODF::lpOD object so you can tweak metadata, styles, and structure before saving. It focuses on straightforward conversion by adding Markdown as paragraphs into the ODF document while exposing the current ODF element and allowing you to append custom elements, which makes it a good fit for scripts that need to generate ODT files from Markdown and then programmatically adjust titles, styles, or other document details. The module is lightweight, MIT licensed, and integrates directly with ODF::lpOD for further manipulation; recent updates improved simple-text performance and removed an old warning workaround that had been producing extra warnings.

IPC::Manager is a Perl library for passing structured messages between processes on the same machine without a central broker. You create or spawn a datastore and share a short connection string, then any process can connect by name and send or receive IPC::Manager::Message objects using a pluggable serializer and a choice of transport backends. Backends include filesystem-based options, atomic pipes, Unix sockets, various SQL databases, and in-memory or shared-memory variants, and the module can pick a suitable protocol automatically or let you specify one. It also provides helpers to spawn lightweight services and named worker processes so you can build simple service trees and request/response patterns while the manager handles client registration, delivery and cleanup. Messages are created and read through a small API so the module fits easily into scripts, daemons and test harnesses that need reliable local messaging. Recent releases focus on robustness and platform compatibility with fixes for Unix sockets on FreeBSD, improved message ordering, central message sorting, and additions like JSONFile and SharedMemory clients and a move to Cpanel::JSON::XS for more reliable JSON handling.

exact::conf is a small extension that brings Config::App's cascading, merged configuration handling into the exact application framework so you can manage layered app settings with minimal wiring. It exports a single helper, conf, which returns a Config::App object and can be loaded via the exact extension interface or directly; you can also opt out of Config::App's default import behavior so you can supply nonstandard config file locations at runtime. The module is useful for Perl developers building exact-based applications who want a simple, tested way to load and merge environment or site-specific configuration files. The recent 1.09 update adds a security policy to address CPANSec guidance.

Yote::YapiServer is a lightweight HTTP server designed to expose a Yote API from a simple Perl program. It listens on a configurable port and endpoint, forks a child process for each incoming connection, parses the HTTP request, and hands API calls off to Yote::YapiServer::Handler. You configure it by creating a new server object with settings such as port, endpoint, library search paths, root_package for your database object, and a database configuration that supports either SQLite (file-based) or MariaDB. Call run to initialize the database store and start the accept loop, making this module a convenient, self-contained way to run a Yote-based API.

Config::App builds a single merged application configuration from multiple YAML or JSON files so you can manage defaults and layered overrides per host, per user, or per environment. It searches up a project directory tree or loads remote files over HTTP, supports include, optional_include and preinclude so files can be combined in different orders, and can record the project root so relative library paths from your config can be injected into @INC. Selectors use pipe-delimited host|user|env strings with a '+' wildcard to apply overrides and the module exposes simple methods to read and write values, return the full merged config, and a find() variant that quietly returns undef if no config is found. The constructor defaults to a singleton for efficiency but you can request separate instances, and all included sources are tracked for debugging. The latest release adds support for preinclude embedded in a section to give finer control over include ordering within scoped overrides.

XML::Enc is a Perl module that adds XML Encryption support so you can encrypt and decrypt XML payloads using public and private keys. It implements standard XML-Enc algorithms and offers a choice of symmetric ciphers like AES and Triple DES and key transport schemes such as RSA-OAEP and RSA 1.5, with sensible defaults of aes256-cbc for data and rsa-oaep-mgf1p for key transport. You create an object with a certificate or private key and call encrypt or decrypt on XML strings, and you can control options like OAEP parameters, label hash, KeyName, and whether to include the XML declaration which is useful for cases like SAML responses. If you need to embed standards-compliant XML encryption into a Perl application for secure transmission or storage of XML documents this module is a straightforward choice.

App::Prove::Plugin::Metrics is a plugin for the prove test runner that emits pass-rate metrics from Perl unit tests so you can feed results into files or external tooling for dashboards and CI. It constructs metric names from configurable pieces such as a prefix, test filename, subtest path and optional assertion label, and lets you control separator characters, allowed characters, and how many nested subtests to include. Output can be written to a plain file or passed to a custom module that provides a save function and may supply default configuration via configureHarness. Metric values can be simple boolean pass/fail flags or rollup percentages. This is useful when you need machine-readable test metrics from existing prove runs. Note that the plugin assumes prove is using the standard console formatter and that rollup behavior may change or be inaccurate under some configurations.

MARC::Validator is a small utility that discovers and exposes validation plugins for MARC bibliographic records so you can see which rule modules are available to validate your catalog data. Its primary method, plugins, returns the names of installed MARC::Validator::Plugin::* modules using Module::Pluggable, making it easy for scripts and tools to enumerate and load field-specific checks such as ISBN, 008/leader consistency, unique identifiers, indexes, UDC, and more. The package is lightweight and focused on plugin discovery rather than performing validation itself. Recent releases expanded many field checks and improved ISBN formatting reporting, and the latest patch fixed packaging metadata in the MANIFEST. Source, license, and authorship are on the project repository.

BitTorrent::Simple is a minimal BitTorrent client that lets you download a single .torrent file to a target directory with a no-frills command-like interface. It implements the basic BitTorrent protocol so you can fetch content but does not include advanced features such as DHT, peer exchange, or simultaneous multiple downloads. Use it when you want a small, easy-to-understand downloader for scripting, testing, or embedding simple torrent capability into a Perl tool. If you need trackerless operation, peer discovery, or a full-featured client, this module will be too limited.

Lingua::Text is a lightweight helper for storing and retrieving the same piece of text in multiple languages, letting you keep all translations in a single object and fetch the right version based on the system LANG or an explicit language argument. You can construct an object from a hash or a single string, set or read language-specific values via methods like $obj->en('Hello') or $obj->fr('Bonjour'), and call as_string to get the current or requested language text. It can also encode stored strings into HTML entities for safe output, but it does not provide a decode method so you should avoid double-encoding. Recent updates validate language codes in the AUTOLOADed accessors and restrict them to two-letter codes. The module is helpful for simple internationalization tasks, though note the unusual license wording that limits personal use to a single computer and asks other users to contact the author.

SimpleMock is a lightweight, extensible mocking framework for Perl that makes it easy to stub subroutines, database access, HTTP clients and simple filesystem calls in tests. It ships with model-driven mock formats for SUBS, DBI, LWP::UserAgent and Path::Tiny and lets you add more models under SimpleMock::Model so teams can share reusable mock definitions. You register mocks globally or temporarily with register_mocks and register_mocks_scoped, and the module maintains a layered stack so scoped mocks override outer ones and are removed when the scope ends. Model modules validate and normalize mock data and provide conveniences such as canned DBI query results and return-value handlers. Be aware that mocks are not versioned so you must ensure compatibility with the real modules you mock, and the author notes potential issues with some XS modules or code that overrides CORE::require; clearing mocks will not restore original sub implementations. The project is on GitHub and contributions to add common adapters are welcome.

SPVM is a statically typed language with Perl-like syntax that lets you write high‑performance code while keeping familiar Perl idioms. It supports ahead‑of‑time and just‑in‑time compilation, can produce standalone executables, and provides tight C and C++ integration plus a Perl binding so you can call SPVM methods from Perl or wrap native libraries. The ecosystem includes many standard and CPAN‑style modules, built‑in support for threads and lightweight coroutines, static typing with inference and analysis, and a focus on performance for numeric and system code. Be aware the project has not reached 1.0 and does not guarantee backward compatibility. Recent work has strengthened the build and packaging toolchain, adding a robust parallel build engine (including Ninja‑style content hashing) and improved cross‑platform linker behavior, and the documentation has been consolidated to make the language and builder APIs easier to use.

Loo is a fast, pure-XS utility for inspecting Perl data structures and for deparsing code references back into readable Perl source. It mimics the familiar Data::Dumper interface while adding built-in ANSI colour output, per-element colour and theme controls, and convenient functional shortcuts Dump, cDump, ncDump and dDump to force or suppress colouring. The object interface exposes Dumper-style options like Indent, Sortkeys, Maxdepth and Deparse plus Colour and Theme for fine-grained appearance and formatting control, and a utility to strip ANSI escapes is provided for plain-text use. Colouring is auto-detected from the environment but can be overridden, making Loo useful for debugging, logging and interactive inspection. Recent updates improved deparsing accuracy and compatibility across Perl releases with fixes for list context, custom ops and several older-Perl edge cases.

Developer::Dashboard gives you a single local home for everyday development tasks by combining a lightweight browser dashboard, a shared CLI entrypoint, and a prompt status layer that all read the same runtime data. It organizes bookmarks, saved pages, quick notes, repeatable actions, background collectors that prepare cached health checks, and compact indicators that drive both the web UI and your shell prompt. The tool also includes helpers for opening files and resolving module or Java class names, small data query commands for JSON/YAML/TOML/properties, and a project-aware Docker Compose resolver so common container workflows live behind one command. It supports layered runtime lookup so project-local ./.developer-dashboard trees can override home defaults without losing shared fallbacks, stages built-in helper scripts privately to avoid polluting your PATH, and provides simple skill extensions you can install from Git for repo-scoped tooling. It is implemented in Perl but works across polyglot projects and ships sensible security defaults like owner-only runtime permissions and optional self-signed HTTPS for the web UI. Recent releases tightened the skill layering behavior so same-repo child layers no longer shadow their base skill and improved the layered skill dispatch, bookmark and config inheritance while adding test coverage for those cases.

Text::ASCII::Convert is a Perl module that normalizes text by replacing non-ASCII characters with visually similar ASCII characters so the result is pure 7-bit ASCII. It accepts either Unicode strings or UTF-8 octets and always outputs characters in the 0x00-0x7F range. The module is aimed at use cases like spam detection and text normalization where attackers or writers substitute accented or foreign letters to hide words because it maps by appearance rather than meaning. That means some letters are transliterated in surprising ways on purpose, for example an eszett may become a capital B and Greek letters may map to visually similar Roman letters. Characters with no ASCII lookalike are turned into spaces and runs of spaces are collapsed, zero-width obfuscation characters are stripped, and control characters such as tabs and newlines are preserved.