CPANscan

TUI::Handy is a tiny, dependency-free Perl module that turns a plain-text layout into an interactive console form using only ANSI escapes, making it ideal for locked-down or old systems where XS modules or external libraries cannot be installed. You write the screen as text and that text becomes the data model so labels become keys in the returned hash, and the DSL supports text fields, numeric and currency fields, checkboxes, radio groups and buttons with simple handlers you register in code. It handles UTF-8, Shift_JIS and EUC-JP widths without loading extra modules, runs on very old Perls, and falls back to a line-oriented mode when full-screen terminal control is not available. Use it for quick configuration wizards, data-entry screens and simple forms on headless servers or embedded images. Note that it is intentionally minimalist: one-screen only, no scrolling, no mouse, limited styling, terminal resizes are not tracked and duplicate labels collide, so for full-featured GUIs Curses::UI or graphical toolkits are more appropriate.

Data::TagDB provides an SQL-backed, general-purpose tagging database for storing semantic information about any kind of object such as files, accounts, or real-world items and then creating, relating, and querying those tags. It gives you high-level operations to create tags, relations and metadata, look up tags by identifiers or human-friendly specifications, iterate over links and metadata, register decoders, and use factories, caches, exporters and migration tools to manage schema upgrades and imports. The module supports SQLite and experimental PostgreSQL backends and exposes both manual transaction methods and a convenient in_transaction helper so you can group operations for much better performance. It also includes a dictionary of well-known tags, parsing support for formats like tagpool and SIRTX, and hooks for integrating with Data::Identifier. Recent updates added support for a "specialises" cloudlet, improved Data::Identifier integration including inserting tagnames from Identifier objects, and expanded SIRTX logical handling, making it a good fit if you need a flexible, schema-migratable system to attach, relate, and query semantic tags in a database-backed application.

Punk is an opinionated MVC web framework for Perl that gives you a simple DSL to declare routes, mounts, middleware, views and models and then compiles everything into a fast, frozen PSGI app at startup. It bundles common web building blocks so you do not need to wire them yourself, including REST verbs, OpenAPI mounting with request validation, static and markdown sites, WebSocket and Server-Sent Events routes, sessions, CSRF protection, CORS and security headers, password-based auth, a per-worker HTTP client and a plugin system. Punk ships a CLI that scaffolds a working app from a template or an OpenAPI file, plus commands for running, testing, generating controllers and managing secrets, and it provides an in-process test client that exercises sessions, CSRF, streaming and websockets. Async handlers are supported via futures and Punk integrates with an event loop for nonblocking IO while remaining usable on standard PSGI servers. If you want a modern, batteries-included Perl framework with fast dispatch and built-in API and realtime features, Punk is worth evaluating.

Test::YAFT is a Perl testing framework that mixes BDD-style readability with an Arrange-Act-Assert workflow to let you write tests that read like specifications using words such as it, assume, there, got, expect, throws, arrange and act. It plugs into Test::Deep and Test::Differences so you get powerful nested structure matching and clear difference reports on failure. The module enforces a hierarchical context model so setup values can be inherited and safely overridden in subtests, supports computed got blocks and shared act blocks for reuse across multiple assertions, and exports a rich set of expectation constructors plus Test::More utilities to make common testing tasks straightforward. It also provides foundation helpers for creating custom comparators and building higher-level test primitives. If you want expressive, self-documenting tests and strong deep-comparison capabilities in Perl, Test::YAFT is worth a look. Documentation may contain occasional non-native English phrasing and the most recent release improved the act {} behavior and other small fixes.

SPVM is a statically typed programming language that uses Perl-like syntax and is designed for high performance and native interoperability. You can run SPVM scripts with the spvm command or produce standalone executables with spvmcc, and the runtime supports AOT and JIT compilation, native threads and lightweight goroutine-style concurrency, plus bindings for C and C++ so you can reuse existing native libraries. SPVM also offers a Perl binding so Perl programs can call SPVM methods and aims to leverage familiar Perl standard functions and modules while adding static typing, type inference and static analysis for safer code. The project is still pre-1.0 and does not guarantee backward compatibility, but it includes documentation, tutorials and examples and targets cross-platform toolchains such as LLVM and MSVC.

Test2::Harness is the backend engine that runs and processes Perl test suites with tight integration for the newer Test2 testing framework. It focuses on executing tests, collecting results, and feeding those results into higher level tools and reporters. Most people will not call it directly because App::Yath provides the user-facing command line and configuration layer built on top of Test2::Harness. Choose this module when you need a modern, Test2-aware harness for building test runners or integrating tests into CI systems, otherwise use App::Yath or existing test runners for everyday testing. The project is open source and hosted on GitHub and is distributed under the same license as Perl.

Open::API is a Perl toolkit for driving both sides of an HTTP API from a single OpenAPI 3.0 or 3.1 document. It loads and compiles the spec at startup into fast, C-backed validators so routing and parameter/schema checks run on a hot path, and it exposes that compiled core to a PSGI server adapter and to a spec-driven HTTP client so one document can produce a server, a client, mocks and docs. The module normalises 3.0 Schema Objects to 3.1 shape at load and expands OpenAPI discriminators so validation and mock generation pick the intended branch, and it offers direct match and validate_request methods for other frameworks, response checking and per-operation coverage counters, and a deterministic response synthesizer useful for predictable mocks. Open::API also publishes a C ABI for embedding the router and validator into native dispatchers and integrates features needed for real deployments such as security scheme enforcement, CSRF and CORS support when used with the Plack adapter. Recent notable work added acceptance of OpenAPI 3.0 documents by converting them to the 3.1/JSON Schema 2020-12 dialect at load so the rest of the toolchain can operate against a single, consistent schema form.

Template::Stencil is a compact, high-performance templating engine for Perl that compiles templates written with a simple "{% %}" syntax into packed bytecode and renders them with a fast C interpreter to produce a single scalar of ready-to-send output. It is designed for low-latency web use: templates compile once and are cached with optional mtime checks, rendering has virtually no per-request heap allocation or syscalls at steady state, automatic HTML escaping is on by default with a raw escape hatch, and you get familiar features like filters, loops, conditionals, includes and a layout wrapper while keeping deterministic output by default. Built-in filters cover common tasks and you can register Perl coderef filters when needed, and the module recently added a vetted fmt filter for sprintf-style formatting with a follow-up fix for long-double/quadmath Perls in the 0.09 release. Template::Stencil handles UTF-8 encoding for you, supports a pretty-print option via an optional dependency, and is safe to use in prefork and ithreads models because each interpreter gets its own engine with no locking. It also exposes a C ABI for embedding in XS code. Note the intentional limitations: templates cannot call methods on blessed references, some advanced features like dynamic includes and expression arithmetic are planned for later, and a few reserved words cannot be used as the first token in a tag.

File::Raw::JSON is a compact, high-performance JSON and JSONL plugin for File::Raw that uses the yyjson C library to parse and emit JSON with minimal overhead. It registers two File::Raw plugins, "json" for single-document files and "jsonl" for NDJSON/JSONL streams, and exposes small XSUBs file_json_decode and file_json_encode for in-memory encode/decode without touching the filesystem. The jsonl path supports memory-bounded streaming via each_line and uses brace-balancing rather than naive newline splitting so pretty-printed records, multi-record lines, and braces inside strings are handled correctly. You get common encoder and decoder options like pretty printing, key sorting/canonical output, relaxed parsing, UTF-8 handling, max depth, and an ordered decode mode that preserves object insertion order at the cost of slower decoding. There is also a published C ABI so XS modules can call the same fast codec from C. The dist vendors yyjson under an MIT license and recent fixes include a 0.07 patch that prevents silent truncation of large integers on 32-bit IV Perls, so numeric fidelity is improved on older platforms.

Dist::Zilla::PluginBundle::Author::GETTY is a ready-made Dist::Zilla plugin bundle that encodes the release workflow and defaults used by the author Getty so you can build, test, version and publish Perl distributions with minimal configuration. It wires together common plugins for metadata, version management, pod weaving, Git/GitHub or Gitea repository metadata, release hooks, optional Docker image publishing, and support for XS or Alien-based builds while offering simple dist.ini switches to opt out of CPAN uploads, include README.md, mark a distro for adoption, or tune which files get $VERSION bumps. The bundle auto-detects GitHub remotes but can target self-hosted Gitea, provides shortcuts to run scripts before and after build or release, and includes a shared GitHub Action for consistent CI. Recent releases fixed some edge cases around version tagging and release commits, most notably ensuring the post-release commit now includes executables in bin/ so scripts are not left one release behind.

GraphViz2::Marpa::PathUtils is a utility for analyzing Graphviz DOT files that helps you discover independent groups of connected nodes and enumerate all paths of a fixed length starting from a given node. It parses DOT input, builds cluster sets and tree representations for each cluster, and can produce DOT, HTML and SVG output so you can inspect or export the results. The module is a subclass of GraphViz2::Marpa and inherits its parsing and configuration options while adding convenient methods and flags for path length, start node, reporting and output naming. It is handy when you need to identify isolated subgraphs or explore specific-length routes through a graph, and the distribution includes example scripts and demo data to get you started. Be aware that the fixed-length path search does not handle edges that point into or out of subgraphs and the allow_cycles option is not implemented in the current minor version.

Filename::KeyValue extracts structured metadata from filenames that use a trailing key=value naming scheme by parsing the prefix, file extension and key/value pairs that are separated by dashes. It understands multiple keys, comma-separated multi-values, and percent-encoded characters and returns an enveloped result containing an HTTP-like status code, a message, the parsed payload and optional metadata. The main routine parse_keyvalue_filename accepts options to control whether values are returned as arrays or as joined strings and whether to URI-decode values. This module is handy when you organize media or other assets by encoding attributes into filenames and need a reliable, exportable helper to read or normalize that information for indexing, routing or processing.

Map::Tube::Plugin::Graph is a plugin role for the Map::Tube family that turns tube network data into Graph objects and rendered maps, letting you produce images of individual lines or an entire network for analysis or display. It integrates with GraphViz2 and the GraphViz command line tools to output PNG, SVG, PDF, DOT/GV and other formats, and offers a flexible render() method to choose format, layout driver, output file naming, and optional base64 encoding while as_png() and as_image() act as convenient wrappers. You can also get a manipulable Graph object from as_graph() to run graph algorithms or decorate edges yourself, and helper methods list_drivers() and list_formats() report what GraphViz supports on your system. Note that it relies on GraphViz2 and an installed GraphViz binary and requires Perl 5.14 or newer. Recent releases added the modern, feature-rich render() API, better output naming and safer filename handling plus expanded tests, with only minor test robustness fixes in the latest patch.

Hyperman is a high-performance PSGI server for running Perl web apps that pairs a prefork supervisor with a per-worker, XS/C event loop to deliver low-latency, high-throughput serving and native async support. It runs any Plack app, lets handlers return Hyperman::Future objects to await asynchronous work without blocking, and exposes timers and io-ready primitives for in-app scheduling. Production features include graceful worker respawn and zero-downtime reloads, multiple listeners (plain and TLS) with SNI and optional client-cert verification, HTTP/2 support, a fast C implemented access log, and a shared forked arena for denylists and fixed-window rate limiting enforced at accept. The module also offers a C ABI so other XS extensions can use its loop and futures directly, and an explicit detach facility for handing live HTTP/1 sockets to an application for protocol upgrades. Recent releases notably added tls_reload to swap certificates per worker and, in the latest update, an attempt to build and serve on native Windows with a WSAPoll backend while keeping existing platform behavior unchanged.

Mojolicious::Plugin::Fondation::Perm::UI::Bootstrap is a lightweight Mojolicious plugin that injects a Bootstrap 5 permission UI into group add/edit modals for apps using Fondation::Perm, so you can present and edit a group's permissions without building the form UI yourself. It adds markup and two small JavaScript helpers: loadPerms(group) fetches available permissions from GET /api/perm and pre-checks those the group already has, and collectPermAssignments() returns the checked permission IDs so your form validation and save logic (for example in DatatableGroup.js) can include the assignments. The permissions block is hidden by default and shown when loadPerms runs, and the plugin is enabled simply from your app config. Recent updates removed the menu icon color and refreshed dependencies in version 0.02.

Mojolicious::Plugin::Fondation::Authorization is a small Mojolicious plugin that loads a user’s grants (group memberships and derived permissions) from the database once per session and provides simple check_perm and check_group helpers for synchronous access control. On the first authenticated request it kicks off an asynchronous fetch via an around_dispatch hook and stores the results in the Mojolicious session so subsequent requests use the cached grants and do not hit the database. Permissions are inherited through group membership only, so there is no direct user-to-permission table. The plugin relies on companion Fondation plugins for authentication, group and permission DB models and the 0.02 release updates dependencies.

Mojolicious::Plugin::Fondation::Auth is a ready-made authentication plugin for Mojolicious apps that need simple DBIx::Class backed login and logout. It wires Mojolicious::Plugin::Authentication to a user model provided by the Fondation stack, installs GET/POST /login and GET /logout routes, and supplies helpers like current_user, authenticate, and logout so you can easily show login state in templates. Password hashing uses Argon2id inside the plugin's Result class so the plugin itself only verifies credentials, and the authentication provider is pluggable so you can swap the default DBIx provider for LDAP, OAuth or a custom backend. Configuration options let you change the model name, username and password column names, session timeout and session key, and the plugin ships a default login template and translations for English and French. If you are building a Mojolicious site that stores users in DBIx::Class and want a quick, configurable login system this plugin is a concise, ready-to-use solution.

Mojolicious::Plugin::Fondation::CSRF is a lightweight plugin that adds Cross-Site Request Forgery protection to Fondation-based Mojolicious applications by reusing Mojolicious' built-in CSRF token machinery. It provides three ways to protect routes: an explicit route condition you can attach to individual actions, automatic protection of POST/PUT/PATCH/DELETE routes generated by Fondation::OpenAPI, and a configurable around_dispatch blanket that checks all mutating requests unless a path matches an exemption pattern. Tokens are stored in the session and validated with Mojo's csrf_protect, and the plugin supports standard form tokens and an X-CSRF-Token header for AJAX calls. It ships a small csrf.js that reads a meta-tag token and patches fetch and XMLHttpRequest to inject the header, and it requires sessions to be enabled and a meta tag in your layout (Layout-Bootstrap provides this automatically). Default behavior auto-protects mutating requests but can be disabled or tuned with exemptions, and this package is a brand new initial release (v0.01).

Mojolicious::Plugin::Fondation::Layout::Bootstrap is a small plugin that supplies a ready-to-use Bootstrap-based layout for Mojolicious applications using the Fondation conventions, making it easy to adopt a consistent page structure and asset handling without crafting templates from scratch. It integrates with Fondation/Mojolicious asset helpers so CSS and other resources are managed for you, and recent updates added a dedicated render zone for head/css along with tests and dependency adjustments to ensure smoother asset integration. If you want a quick, convention-driven Bootstrap layout for a Mojolicious app, this module gives you that foundation with minimal setup.

Mojolicious::Plugin::Fondation::OpenAPI generates an OpenAPI 3.0.3 specification from DBIx::Class models for Fondation applications and provides runtime request validation and optional Swagger UI integration. It offers an "openapi generate" command that writes share/openapi.json and a client-side public/js/validators.js used by Fondation assets, and the app loads the spec at startup via Mojolicious::Plugin::OpenAPI to validate requests and wire route-level permission checks. You can control which database backend is used, override schema and column properties without touching DBIx classes, disable client-side validation for testing, and mark tables as excluded through plugins with fondation_meta. Permission annotations from schemas are translated into route requires so API protection matches HTML routes, and Swagger UI routes are added automatically in development. The plugin depends on Fondation::Model::DBIx::Async and Mojolicious::Plugin::OpenAPI, and there is a known compatibility issue on Perl 5.40 caused by a downstream dependency that can be worked around on Debian by installing libnet-idn-encode-perl. Run openapi generate before asset generation to keep the spec and client validators in sync.

Mojolicious::Plugin::Fondation::Menu is a plugin that gives Mojolicious apps a simple way to declare, store and render navigational menus and breadcrumbs. Plugins declare their menu items in share/menus.json and a provided "menu sync" command imports those items into a small database table so you get hierarchical menus, ordering, parent/child relationships, optional FontAwesome icons, conditional visibility based on group or permission, and per-item metadata like description and whether an item should appear in the menu. The plugin exposes convenient helpers for fetching menus, rendering menus and breadcrumbs, checking conditions, and it also surfaces a RESTful API with create/read/update/delete endpoints and fine-grained menu permissions. It is a good fit if you need centralized, declarative control of navbars and breadcrumbs across a modular Mojolicious app. Recent updates require Fondation::Model::DBIx::Async 0.06 and remove the separate icon color field.

This plugin adds real dictionary-based internationalization to Fondation apps by replacing the default identity helpers with proper translations. At startup it scans each plugin's share/translations/<lang>.json files, merges them into per-language lexicons kept on the app, and exposes them via a helper so lookups are fast at runtime. For each request it detects the user language from a URL prefix or the Accept-Language header, stores a reference to the right lexicon in the request stash, and the l() helper performs a single hash lookup to return translations. For client-side code it can inject a script with the current language translations and a window.l function, and it also registers an /i18n/<lang>.json endpoint for dynamic loading. You can configure a fallback default language and which language codes are allowed in the URL. Translation files use English strings as keys and are merged at startup with last-write-wins for duplicate keys.

Mojolicious::Plugin::Fondation::Group::UI::Bootstrap is a small UI plugin that adds a Bootstrap 5 web interface for managing user groups in a Mojolicious app that uses the Fondation family of plugins. It is the front end companion to the Fondation::Group backend and automatically injects group controls into existing user add/edit forms, adds a /groups administration page with a DataTable and inline add/edit/delete modals, wires JavaScript helpers to load and gather group assignments, and provides translated labels and a menu entry under Administration. Permission checks are supported so buttons and actions only appear to authorized users. If you already use Fondation::Group and the Bootstrap layout plugin, this module gives you a ready-made, integrated group management UI with minimal wiring.

Mojolicious::Plugin::Fondation::User::UI::Bootstrap is a Mojolicious plugin that provides a ready-made Bootstrap 5 web interface for user management in Fondation-based applications, delivering templates, JavaScript assets, and translations so you can list, create, edit, assign roles or groups, and activate or deactivate users through a DataTable with inline editing and modal dialogs. It registers a GET /users route protected by the fondation.perm => user_list condition and relies on the generic REST actions supplied by Fondation::User while expecting Fondation::Layout::Bootstrap to provide the page layout. The plugin ships EP templates, a DatatableUser.js client module, and English and French lexicons, and it is configurable with a page title that defaults to "User Management". Current release is 0.03 and includes a basic load test and updated dependency declarations.

Mojolicious::Plugin::Fondation::User is a user-management add-on for Mojolicious apps using the Fondation framework that supplies a ready-made users table with schema, Result and ResultSet classes, an OpenAPI-driven REST controller for standard CRUD operations, and an optional Bootstrap-based HTML UI. It automatically hashes passwords with Argon2 via Crypt::Passphrase in the async DB worker so the event loop stays responsive and the password field is never returned in API responses. Convenience ResultSet helpers like active, created_today and latest simplify common queries and the with('groups') option performs a single-query prefetch of many-to-many group relations so group objects can be embedded in responses without extra database round trips. API notification translations for English and French are included. Note that recent releases require Fondation::Model::DBIx::Async 0.06.

Mojolicious::Plugin::Fondation::MigrationDBIx adds a simple "db" toolset to Fondation apps that use DBIx::Class via Fondation::Model::DBIx::Async, letting you generate and apply schema migrations and load fixture data without leaving your app. It generates upgrade and downgrade SQL from your schema classes, copies plugin-provided fixture directories into the application, detects the database driver from the DSN, and exposes commands such as bootstrap-schema, prepare, install, upgrade, downgrade, status and populate to manage the full migration workflow. A helper reports schema drift between the live database and the prepared migration files and the plugin keeps per-version fixture sets so you can populate test or initial data cleanly. Configuration is minimal, with options for the target backend and migrations directory, and recent updates improve fixture dependency handling and compatibility while aligning this release with Fondation::Model::DBIx::Async 0.06. If you maintain a Mojolicious app backed by DBIx::Class and want integrated, plugin-aware migration and fixture management, this module is directly relevant.

Mojolicious::Plugin::Fondation::Workflow::UI::Bootstrap is a small Mojolicious plugin that provides ready-made Bootstrap 5 UI helpers for Fondation::Workflow so you can display workflow state, available actions, progress and history with minimal effort. It installs five template helpers that accept a Fondation::Workflow::Proxy and return HTML fragments for badges, action button groups, a text-based progress tree and a vertical timeline, while a separate helper emits a raw Mermaid.js flowchart definition for diagram rendering. Labels, colors and icons are driven by a fondation block in your workflow YAML and fall back to sensible defaults when absent. The plugin requires Fondation::Layout::Bootstrap and Fondation::Workflow and is useful for developers who want consistent, Bootstrap-styled workflow interfaces without building the markup by hand.

CPANSA::DB packages the CPAN Security Advisory feed as a ready-to-use Perl data structure and exposes a single db method that returns a hash reference of all advisory reports. It is used by CPAN::Audit but can be used by any Perl program that needs a local, programmatic snapshot of CPAN security advisories. Releases are distributed on GitHub and include a JSON equivalent, GPG signatures, and GitHub attestations so you can verify the archive came from the official source before trusting the data. Use this module when you want an easy, verifiable way to load CPAN advisory data into your Perl code.

HTTP::API::Core is a lightweight, composable foundation for building JSON HTTP API clients in Perl. It centralizes base URL and default header handling, provides convenience methods for common HTTP verbs, and makes JSON encoding and decoding straightforward while letting you configure timeouts and a conservative automatic retry policy with exponential backoff and jitter. The module includes pagination helpers for next-url, page-number, and cursor styles, normalizes common rate-limit headers into a simple rate-limit object, and returns structured errors with useful metadata so callers can decide how to handle failures. Lifecycle hooks let you inject authentication, tracing, or custom headers before requests and inspect responses or errors afterward. The transport layer is pluggable so you can supply a code reference or an object that implements a request method. This 0.01 release also marks a namespace rename from the pre-release HTTP::API::Client project and intentionally keeps higher-level concerns like logging and metrics out of the core so you can build your own service-specific clients on top.

JSON::Schema::Fast is a high-performance JSON Schema (draft 2020-12) validator for Perl that compiles a schema once into a compact intermediate form and then validates live Perl data through a tight C interpreter, making repeated validations extremely fast. You create a compiled validator from a hashref, boolean schema, or JSON text and then call is_valid for a cheap boolean check or validate to collect detailed error hashes that include JSON Pointer locations, failing keywords, schema pointers, and human messages. It implements the full 2020-12 keyword set including references and remote documents, and it offers options to coerce common string representations into numbers or booleans and to apply declared defaults into the data before validation. Remote $ref resolution uses a pluggable resolver and by default will fetch documents via Fetch's C ABI, so you can supply your own resolver or disable remote lookups to avoid outbound requests. The distribution is fully conformant to the official test suite and exposes a small C ABI so XS authors can perform schema compilation and validation entirely in C for ultra-low-overhead use cases such as high-volume OpenAPI request validation.