man > CGI::Application::Plugin::ErrorPage(3pm)

Che Dong
The user wants me to transform a Perl man page HTML into an emoji-rich, visually scannable version. Let me carefully follow all the rules. Let me analyze the input: - It's a CGI::Application::Plugin::ErrorPage Perl module documentation - I need to preserve structure but add emojis - Start with
(no

) - All code in

- Lists in proper HTML tags
- Add a Quick Reference section after NAME
- Avoid XSS - escape bare < and >

Let me plan the structure:
1. NAME section - skip the NAME header since h1 should be the page title, but they want h2... wait, looking at the rule again: "NEVER use  — the page already has an H1 title. Start from 
". So NAME should be an h2.

Actually wait - this whole content IS being placed as the body. The h1 of the page is whatever the page title is. So I need to convert:
- NAME, SYNOPSIS, DESCRIPTION, METHODS, SUPPORT, AUTHOR, COPYRIGHT, SEE ALSO → h2
- Sub-sections like "A better default error page", "Relation to error_mode()", "Suggested Uses", "Silliness", "error()", "Example error.html" → h3

Let me also add a Quick Reference section after NAME.

For the code blocks - I need to wrap all code in  tags. Let me identify them:

SYNOPSIS code:
```
use CGI::Application::Plugin::ErrorPage 'error';

sub my_run_mode {
  my $self = shift;

  eval { .... };

  if ($@) {
      # Send the gory details to the log for the developers
      warn "$@";

      # Send a comprehensible message to the users
      return $self->error(
          title => "Technical Failure',
          msg   => "There was a techical failure during the operation.",
      );
  }

}
```

Default error page:
```
return $c->error(
    title => 'The requested page was not found.',
    msg => "(The page tried was: ".$c->get_current_runmode.")"
);
```

error() example:
```
return $self->error(
    title => "Technical Failure',
    msg   => "There was a techical failure during the operation",
);
```

Custom error page:
```
# In this case, intentionally *don't* import 'error' to avoid a "redefined" warning.
use CGI::Application::Plugin::ErrorPage;
sub error {
     my $c = shift;
     return $c->CGI::Application::Plugin::ErrorPage::error(
         tmpl => $self->cfg('ROOT_URI').'/path/to/my/alternate/error/file.html',
         @_,
     );
}
```

Roll your own:
```
use Params::Validate ':all';
sub error {
    my $self  = shift;
    my %p = validate(@_, { title => SCALAR, msg => SCALAR });
    my $t = $self->load_tmpl;
    $t->param( title => $p{title}, msg => $p{msg} );
    return $t->output;
}
```

Example error.html:
```








```

Suggested Uses list items with asterisks need to be converted to proper ul/li.

XSS check: In the code blocks, I have things like `->error(`, `$@`, etc. All the arrows and such are fine because they're in code blocks. But anywhere I have bare < or > outside code blocks I need to escape.

For Example error.html section - the entire block contains < and > - but it's already in code block, so that's fine.

Wait, the input shows `<` and `>` because the original HTML has already encoded them. So I need to keep them encoded.

Looking at this code section more carefully:
```
<!DOCTYPE html
        PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
```

There are `` tags in this code block. Rule 8 says: "NEVER put  inside a  block. The copy-button will break and the code becomes invalid."

So I need to REMOVE the `` tags from inside this code block. But wait, they were in the original... I need to keep the code EXACTLY as is. Hmm, this is a conflict.

Actually rule 8 says: "Code blocks MUST contain EXACT original code — NO changes, NO added links, NO emoji inside . NEVER put  inside a  block."

So the rule is that I shouldn't put  inside code blocks. The original code has them, which is a content issue from the source. But my output should not have  inside .

I think the proper interpretation is: when emitting the code in my output's , I should strip the  tags (they're not part of the code, they're HTML markup that leaked into the code block from the source).

So the clean version should be:
```
<!DOCTYPE html
        PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
...
```

Also need to do this throughout the document - anywhere `` is wrapping code or function names. Let me check each occurrence...

Looking at the input:
- `CGI::Application::Plugin::ErrorPage` - this is the name reference, keep as link but outside code
- `sub my_run_mode {` - this has nothing problematic but is in a code block
- `$self->error(` - properly encoded

I need to be careful when stripping links - they were in the original document. Let me think... The rule says preserve original content but don't put  inside . So when the source has them inside what should be a , I strip them.

Actually, looking more carefully, in the original document, many references that ARE links in normal text are NOT inside pre/code blocks originally. Let me identify which  tags are inside actual code regions vs. in regular prose:

In SYNOPSIS section, "use CGI::Application::Plugin::ErrorPage 'error';" - the link wraps "CGI::Application::Plugin::ErrorPage" - this IS code. So when I put this in a , I need to strip the link.

Let me handle this systematically. I'll identify each region of code and emit it with appropriate adjustments.

Let me reformat the whole document now.

Actually for the Silliness section:
```
[22:36]  Techno Failure. We were cruising along and rocking out while fulfilling your request, but then the music stopped and we sort of got distracted.
[22:36]  Tek Failure. Too busy reading Shatner novels to respond to your request.
```

This has < and > but it's not code - it's conversation log. I need to escape them as < and >. So:
`<rjbs>`

Now, the Quick Reference section:
For CGI::Application::Plugin::ErrorPage, I can list common use cases:

| Use Case | Command | Description |
|----------|---------|-------------|
| Basic error | `return $self->error(title => 'Err', msg => 'Msg')` | Return an error page |
| With template | `$self->error(tmpl => 'path/to/error.html', title => '...', msg => '...')` | Use a custom template file |
| Catch exceptions | `eval { ... }; if ($@) { warn "$@"; return $self->error(...) }` | Handle exceptions and report |
| 404 | `$c->error(title => 'Not Found', msg => '...')` | Provide a default 404 |
| Custom error() | `sub error { $c->CGI::Application::Plugin::ErrorPage::error(tmpl => ..., @_) }` | Use a custom template location |

Let me now construct the full HTML.

Let me also handle the section headers properly. The original has weird capitalization - I'll keep that as is.

For the methods section, the "error()" should become error().

Let me look at the structure:
- NAME (h2)
- 🚀 Quick Reference (h2)
- SYNOPSIS (h2)
- DESCRIPTION (h2)
  - A better default error page (h3)
  - Relation to error_mode() (h3)
  - Suggested Uses (h3)
  - Silliness (h3)
- METHODS (h2)
  - error() (h3)
  - Example error.html (h3)
- SUPPORT (h2)
- AUTHOR (h2)
- COPYRIGHT (h2)
- SEE ALSO (h2)

Now let me select good emojis for each:
- NAME - 📛
- Quick Reference - 🚀
- SYNOPSIS - 📝
- DESCRIPTION - 📖
- A better default error page - 🎯
- Relation to error_mode() - 🔗
- Suggested Uses - 💡
- Silliness - 🤪
- METHODS - ⚙️
- error() - 🛠️
- Example error.html - 📄
- SUPPORT - 💬
- AUTHOR - 👤
- COPYRIGHT - ©
- SEE ALSO - 🔗 (or 📚)

For the Title hyperlinks, preserve them as link.

For lists:
- Suggested Uses - has * bullets, convert to ul/li
- Other lists?

Actually wait - "Suggested Uses" uses asterisks like "* 'Technical Failure' - The software failed unexpectedly". These should be converted to proper ul/li.

Now let me carefully format the code:

SYNOPSIS code block:
```
use CGI::Application::Plugin::ErrorPage 'error';

sub my_run_mode {
  my $self = shift;

  eval { .... };

  if ($@) {
      # Send the gory details to the log for the developers
      warn "$@";

      # Send a comprehensible message to the users
      return $self->error(
          title => "Technical Failure',
          msg   => "There was a techical failure during the operation.",
      );
  }

}
```

Wait, in the original: `title => "Technical Failure',` has a typo - opens with " but closes with '. I'll preserve as-is.

Also: `>error(` needs to become `->error(` in code. The HTML entity for > is > but in code it's just >. Since I'm putting it in , the rendering will show it correctly. Actually the entity should be just `>` in code blocks. Let me check - in HTML , if I have `>` literally written, it will render as `>`. That's correct.

Let me write out the final HTML now.

One more thing - the suggested uses list:
* "Technical Failure" - The software failed unexpectedly
* "Insufficient Information" - some required query parameter was missing
* "Request Not Understood" - Some value we received in the query just didn't make sense.

I'll add an emoji prefix to each.

For the "See Also" link to perl(1):
`perl(1)` is wrapped in perl(1) - keep this link.

For the "Silliness" section, I need to escape < and > as < and >:
`[22:36] <rjbs> Techno Failure...`
`[22:36] <rjbs> Tek Failure...`

OK let me now write the full output.

For the quick reference table, I want to use  not  in table cells per rule 21.

Let me also remember rule 19: Add descriptive emoji to option descriptions and list item text.

For lists:
- Suggested Uses items get emoji prefix
- Quick Reference description column may have emoji

For the error() method description, the original prose has details - I might add an emoji or keep it plain.

Let me also be careful about the AUTHOR section - it's a small block with contact info. I'll keep it simple.

Now drafting:

```html
📛 NAME
CGI::Application::Plugin::ErrorPage - A simple error page plugin for CGI::Application

🚀 Quick Reference

...

Use Case Command Description
Basic error return $self->error(title => 'Err', msg => 'Msg') 📋 Return an error page
```

Hmm, the  with -> won't render correctly. Actually inside  entities work fine. Let me check - $self->error() would render as `$self->error()`. That's correct.

Actually, inside  tags I can write `>` and it'll display as `>`. But within pre> the same applies.

Actually, the simplest is to write `>` as `>` and rely on the browser's HTML parser... no wait, in HTML, you have to escape < and >. So $self->error() would be INVALID HTML because the browser might think `>` ends a tag.

Wait, no. > is technically allowed in HTML content. But < is forbidden except as part of a tag. So  has < which starts the tag, then content has $self and > - the > ends the tag, which is wrong.

The safe way is to use entities. So: $self->error() — when the browser sees >, it renders as >.

OK so I need to escape > inside  and elsewhere. Let me be careful.

Actually for the Quick Reference table:
- Command cells use 
- All > and < in those cells should be entities

Alright, let me write it out now.

Wait, I should think about the table:
```
Basic errorreturn $self->error(title => 'Err', msg => 'Msg')📋 Return an error page
```

Yes that's correct.

Let me now think about the "Silliness" content. The original:
```
[22:36]  Techno Failure.  We were cruising along and rocking out while fulfilling your request, but then the music stopped and we sort of got distracted.
[22:36]  Tek Failure.  Too busy reading Shatner novels to respond to your request.
```

This is a quote-like content. I'll wrap in  since it's more like a log/chat.

Actually it's not really code. Let me use a  with line breaks:
```

[22:36] <rjbs> Techno Failure...

[22:36] <rjbs> Tek Failure...

```

Or just paragraphs:
```
[22:36] <rjbs> Techno Failure. We were cruising along...
[22:36] <rjbs> Tek Failure. Too busy reading Shatner novels...
```

I'll use paragraphs with line breaks.

Now the final structure. Let me also think about sizes - the user wants under 128,000 characters. The original isn't too long, so we're fine.

Let me write it all out:

```html
📛 NAME
CGI::Application::Plugin::ErrorPage — A simple error page plugin for CGI::Application 🎯

🚀 Quick Reference


Use Case Command Description


🛠️ Basic error return $self->error(title => '...', msg => '...') 📋 Display an error page
📂 Custom template $self->error(tmpl => 'path/to/error.html', title => '...', msg => '...') 🎨 Use a custom template file
🚨 Exception handling eval { ... }; if ($@) { warn $@; return $self->error(...) } ⚠️ Catch exceptions and report
❌ 404 Not Found $c->error(title => 'Not Found', msg => '...') 🚫 Provide a default 404
📍 Custom location sub error { my $c = shift; $c->CGI::Application::Plugin::ErrorPage::error(tmpl => ..., @_) } 📁 Override error() to use a fixed template path



📝 SYNOPSIS
use CGI::Application::Plugin::ErrorPage 'error';

sub my_run_mode {
  my $self = shift;

  eval { .... };

  if ($@) {
      # Send the gory details to the log for the developers
      warn "$@";

      # Send a comprehensible message to the users
      return $self->error(
          title => "Technical Failure',
          msg   => "There was a techical failure during the operation.",
      );
  }

}

📖 DESCRIPTION
This plugin provides a shortcut for the common need of returning a simple error message to the user.
You are encouraged to provide a template file so that the error messages can be presented with a design consistent with the rest of your application.
A simple design is provided below to get you started. 🚀

🎯 A Better Default Error Page
If you don't install an AUTOLOAD run mode in the normal way in setup, this plugin will automatically install a reasonable default at the prerun stage, which returns an error page like this:
return $c->error(
    title => 'The requested page was not found.',
    msg => "(The page tried was: ".$c->get_current_runmode.")"
);

🔗 Relation to error_mode()
CGI::Application includes error_mode() to provide custom handling when the application dies. This error() routine provides a shortcut for displaying error messages to the user. So, they both have a place on their own, and it could make sense to use them together. In your 'error_mode' routine, you might call error() to return a message to the user:
$self->error( title => 'Technical Failure', msg => 'There was a technical failure' );

💡 Suggested Uses
Some common cases for returning error messages to the user include:

💥 "Technical Failure" — The software failed unexpectedly
📭 "Insufficient Information" — Some required query parameter was missing
🤔 "Request Not Understood" — Some value we received in the query just didn't make sense.


🤪 Silliness
[22:36] <rjbs> Techno Failure. We were cruising along and rocking out while fulfilling your request, but then the music stopped and we sort of got distracted.
[22:36] <rjbs> Tek Failure. Too busy reading Shatner novels to respond to your request.

⚙️ METHODS

🛠️ error()
return $self->error(
    title => "Technical Failure',
    msg   => "There was a techical failure during the operation",
);
Nothing fancy, just a shortcut to load a template meant to display errors. I've used it for the past several years, and it's been very handy to always have around on projects to quickly write error handling code. 🧰
It tries to load a template file named 'error.html' to display the error page. 📄
If you want to use a different location, I recommend putting something like this in your base class, so you only have to provide your error template location once. 📍
# In this case, intentionally *don't* import 'error' to avoid a "redefined" warning.
use CGI::Application::Plugin::ErrorPage;
sub error {
     my $c = shift;
     return $c->CGI::Application::Plugin::ErrorPage::error(
         tmpl => $self->cfg('ROOT_URI').'/path/to/my/alternate/error/file.html',
         @_,
     );
}
This module intentionally ignores any tmpl_path() set by application, since this is usually an indication of where the intended file is located, not the error template. This exceptional handling of the tmpl_path() is one of the only value added bits of logic that this plugin adds. The rest of it is primarily a simple recommendation for error page handling wrapped up as a module. 🎁
If you don't want this behavior, it's simple enough just to roll your own error() page method and skip using this plugin. Here's the simple essential code: 🔧
use Params::Validate ':all';
sub error {
    my $self  = shift;
    my %p = validate(@_, { title => SCALAR, msg => SCALAR });
    my $t = $self->load_tmpl;
    $t->param( title => $p{title}, msg => $p{msg} );
    return $t->output;
}

📄 Example error.html
Here's a very basic example of an error.html file to get you started. 🚀
<!DOCTYPE html
        PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en-US" xml:lang="en-US">
<head>
<title><!-- tmpl_var title escape=HTML --></title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
</head>
<body>
<h1><!-- tmpl_var title escape=HTML--></h1>
<p><!-- tmpl_var msg escape=HTML --></p>
</body>
</html>
We manage site-wide designs with Dreamweaver and keep a basic 'error.html' that uses a generic Dreamweaver 'page.dwt' template with standard EditableRegion names. That way, we can copy this error.html into a new Dreamweaver-managed project and have the new design applied to it easily through Dreamweaver. 🎨

💬 SUPPORT
Ask for help on the CGI::Application mailing list. Report bugs and wishes through the rt.cpan.org bug tracker. 🐛

👤 AUTHOR
Mark Stosberg

CPAN ID: MARKSTOS

mark AT summersault.com

📜 COPYRIGHT
This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. 🎁
The full text of the license can be found in the LICENSE file included with this module. 📜

🔗 SEE ALSO
perl(1).
```

Wait, I need to double-check rule 8 about the example error.html code. Looking at the source:
```
http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd
```

This is INSIDE the code block (or at least it's code). I need to strip the  per rule 8. So the code becomes:
```
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"
```

That's good - clean code without HTML tags.

Same for `xmlns="http://www.w3.org/1999/xhtml"` - strip a tag.

Let me also check the "use CGI::Application::Plugin::ErrorPage 'error';" - in the original it was `use CGI::Application::Plugin::ErrorPage 'error';` - strip the link.

OK, I'll write out the final version now.

One more concern - the rule about relative ordering. The rule says "Section titles (NAME, SYNOPSIS, DESCRIPTION, OPTIONS, EXAMPLES, SEE ALSO) →  with ONE emoji prefix". So one emoji each.

Let me now finalize.

For the function reference sections, rule 12 says: use name(args) — description format WITHOUT per-item emoji. This applies to pydoc modules, ruby ri classes, perldoc function lists. But this isn't really a function reference - it's a method documentation page. The error() section doesn't have a function list per se. So I think the regular rules apply.

Let me also think about quick reference. The use cases should be generic enough. Let me revise:

| Use Case | Command | Description |
|----------|---------|-------------|
| Display error | `return $self->error(title => '...', msg => '...')` | Render an error page |
| Custom template path | `$self->error(tmpl => 'path/to/error.html', title => '...', msg => '...')` | Use a custom error template |
| Catch and report | `eval { ... }; if ($@) { warn $@; return $self->error(...) }` | Wrap risky code in eval |
| 404 handler | `$c->error(title => 'Not Found', msg => '...')` | Use the default 404 page |
| Override error() | `sub error { ... $c->CGI::Application::Plugin::ErrorPage::error(tmpl => ..., @_) }` | Pin a custom template location |

Add emoji to descriptions - good.

Now for the final output - I want to make sure I don't exceed length. Let me check the response size. The HTML shouldn't be too long.

Let me finalize the output now.

Actually, I need to re-check the Silliness section. Let me look at the source once more. The original has:
```
[22:36]  Techno Failure.  We were cruising along and rocking out while fulfilling your request, but then the music stopped and we sort of got distracted.
[22:36]  Tek Failure.  Too busy reading Shatner novels to respond to your request.
```

The  needs to be escaped as <rjbs>. Outside any code block, that's fine.

OK final output coming up.

One more consideration - in the source code there's this:
```
title => "Technical Failure',
```

This has a mismatched quote (opening double, closing single). I'll preserve this exactly as it's in the original code. Same with the typo "techical" instead of "technical".

Let me check on if I should escape "quotes" inside code blocks. No, " is allowed inside code. So that's fine.

Alright, I'm ready to write the final HTML.

Actually wait, I just realized I should double check - the original prose has these rather unusual structures:
```
       NAME
       CGI::Application::Plugin::ErrorPage - A simple error page plugin for CGI::Application
```

The NAME section has the module name and a description. The description has  tags wrapping "CGI::Application::Plugin::ErrorPage" and "CGI::Application". These should be preserved as links in my output.

For the structure, let me also consider whether to put emoji inside links or just before. I'll put emoji OUTSIDE the link, then the link.

Final version coming up. Let me also recheck rule 21 says - Quick Reference ALWAYS as second section. Right after NAME. Confirmed.

For the table - simple table with th, tr, td.

Looking at the original, the suggested uses section had asterisks. Let me convert to ul/li.

Actually let me re-read: rule 10: Use standard  or  for ALL lists. Emoji may appear inside  text content, but NEVER replace the list structure with emoji-only lines.

So I keep the list structure, and emoji can be in the text content.

OK writing the final version now.

For the table, I should also make sure code in cells is correctly formatted with entities. Let me write out:

```html

...

Use Case Command Description
🛠️ Display error return $self->error(title => '...', msg => '...') 📋 Render an error page
```

Looks good. Now the final output.

📛 NAME
CGI::Application::Plugin::ErrorPage — A simple error page plugin for CGI::Application

🚀 Quick Reference


Use Case Command Description


🛠️ Display error return $self->error(title => '...', msg => '...') 📋 Render an error page from the default error.html template
📂 Custom template $self->error(tmpl => 'path/to/error.html', title => '...', msg => '...') 🎨 Use a custom template file for the error page
🚨 Catch and report eval { ... }; if ($@) { warn $@; return $self->error(...) } ⚠️ Wrap risky code, log the error, return a user-friendly page
❌ 404 handler $c->error(title => 'Not Found', msg => '(tried: '.$c->get_current_runmode.')') 🚫 Use the default prerun-installed not-found page
📍 Override error() sub error { $c->CGI::Application::Plugin::ErrorPage::error(tmpl => ..., @_) } 🔧 Pin a fixed template path in your base class
✍️ Roll your own sub error { my %p = validate(@_, {title => SCALAR, msg => SCALAR}); ... } 🧱 Skip this plugin entirely with a minimal hand-written error()



📝 SYNOPSIS
use CGI::Application::Plugin::ErrorPage 'error';

sub my_run_mode {
  my $self = shift;

  eval { .... };

  if ($@) {
      # Send the gory details to the log for the developers
      warn "$@";

      # Send a comprehensible message to the users
      return $self->error(
          title => "Technical Failure',
          msg   => "There was a techical failure during the operation.",
      );
  }

}

📖 DESCRIPTION
This plugin provides a shortcut for the common need of returning a simple error message to the user. 📨
You are encouraged to provide a template file so that the error messages can be presented with a design consistent with the rest of your application. 🎨
A simple design is provided below to get you started. 🚀

🎯 A Better Default Error Page
If you don't install an AUTOLOAD run mode in the normal way in setup, this plugin will automatically install a reasonable default at the prerun stage, which returns an error page like this:
return $c->error(
    title => 'The requested page was not found.',
    msg => "(The page tried was: ".$c->get_current_runmode.")"
);

🔗 Relation to error_mode()
CGI::Application includes error_mode() to provide custom handling when the application dies. This error() routine provides a shortcut for displaying error messages to the user. So, they both have a place on their own, and it could make sense to use them together. In your 'error_mode' routine, you might call error() to return a message to the user:
$self->error( title => 'Technical Failure', msg => 'There was a technical failure' );

💡 Suggested Uses
Some common cases for returning error messages to the user include:

💥 "Technical Failure" — The software failed unexpectedly
📭 "Insufficient Information" — Some required query parameter was missing
🤔 "Request Not Understood" — Some value we received in the query just didn't make sense.


🤪 Silliness

[22:36] <rjbs> Techno Failure. We were cruising along and rocking out while fulfilling your request, but then the music stopped and we sort of got distracted. 🎸
[22:36] <rjbs> Tek Failure. Too busy reading Shatner novels to respond to your request. 📚


⚙️ METHODS

🛠️ error()
return $self->error(
    title => "Technical Failure',
    msg   => "There was a techical failure during the operation",
);
Nothing fancy, just a shortcut to load a template meant to display errors. I've used it for the past several years, and it's been very handy to always have around on projects to quickly write error handling code. 🧰
It tries to load a template file named 'error.html' to display the error page. 📄
If you want to use a different location, I recommend putting something like this in your base class, so you only have to provide your error template location once. 📍
# In this case, intentionally *don't* import 'error' to avoid a "redefined" warning.
use CGI::Application::Plugin::ErrorPage;
sub error {
     my $c = shift;
     return $c->CGI::Application::Plugin::ErrorPage::error(
         tmpl => $self->cfg('ROOT_URI').'/path/to/my/alternate/error/file.html',
         @_,
     );
}
This module intentionally ignores any tmpl_path() set by application, since this is usually an indication of where the intended file is located, not the error template. This exceptional handling of the tmpl_path() is one of the only value added bits of logic that this plugin adds. The rest of it is primarily a simple recommendation for error page handling wrapped up as a module. 🎁
If you don't want this behavior, it's simple enough just to roll your own error() page method and skip using this plugin. Here's the simple essential code: 🔧
use Params::Validate ':all';
sub error {
    my $self  = shift;
    my %p = validate(@_, { title => SCALAR, msg => SCALAR });
    my $t = $self->load_tmpl;
    $t->param( title => $p{title}, msg => $p{msg} );
    return $t->output;
}

📄 Example error.html
Here's a very basic example of an error.html file to get you started. 🚀
<!DOCTYPE html
        PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en-US" xml:lang="en-US">
<head>
<title><!-- tmpl_var title escape=HTML --></title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
</head>
<body>
<h1><!-- tmpl_var title escape=HTML--></h1>
<p><!-- tmpl_var msg escape=HTML --></p>
</body>
</html>
We manage site-wide designs with Dreamweaver and keep a basic 'error.html' that uses a generic Dreamweaver 'page.dwt' template with standard EditableRegion names. That way, we can copy this error.html into a new Dreamweaver-managed project and have the new design applied to it easily through Dreamweaver. 🎨

💬 SUPPORT
Ask for help on the CGI::Application mailing list. Report bugs and wishes through the rt.cpan.org bug tracker. 🐛

👤 AUTHOR

  Mark Stosberg

  CPAN ID: MARKSTOS

  mark AT summersault.com


📜 COPYRIGHT
This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. 🎁
The full text of the license can be found in the LICENSE file included with this module. 📄

🔗 SEE ALSO
perl(1).
🚀 Quick Reference

📝 SYNOPSIS

📖 DESCRIPTION

🎯 A Better Default Error Page

🔗 Relation to `error_mode()`

💡 Suggested Uses

🤪 Silliness

⚙️ METHODS

🛠️ `error()`

📄 Example `error.html`

💬 SUPPORT

👤 AUTHOR

📜 COPYRIGHT

🔗 SEE ALSO

man > CGI::Application::Plugin::ErrorPage(3pm)

(no

— the page already has an H1 title. Start from

error()

📛 NAME

🚀 Quick Reference

📛 NAME

🚀 Quick Reference

📝 SYNOPSIS

📖 DESCRIPTION

🎯 A Better Default Error Page

🔗 Relation to error_mode()

💡 Suggested Uses

🤪 Silliness

⚙️ METHODS

🛠️ error()

📄 Example error.html

💬 SUPPORT

👤 AUTHOR

📜 COPYRIGHT

🔗 SEE ALSO

📛 NAME
