@stacksjs/defaults 0.70.206 → 0.70.208

package/ai/skills/stacks-email/SKILL.md

@@ -0,0 +1,236 @@
+---
+name: stacks-email
+description: Use when working with email in a Stacks application — sending emails via SES/SendGrid/Mailgun/Mailtrap/SMTP, email templates with STX, email drivers, the Mail singleton, the EmailSDK for inbox management, or email configuration. Covers @stacksjs/email, config/email.ts, and app/Mail/.
+license: MIT
+compatibility: Bun >= 1.3.0, TypeScript
+allowed-tools: Read Edit Write Bash Grep Glob
+---
+
+# Stacks Email
+
+Multi-driver email system with template rendering, S3-based inbox management, and 5 built-in drivers.
+
+## Key Paths
+- Core package: `storage/framework/core/email/src/`
+- Configuration: `config/email.ts`
+- Application mail: `app/Mail/`
+- Email layouts: `storage/framework/defaults/resources/emails/layouts/`
+- Email resources: `storage/framework/defaults/resources/emails/`
+
+## Source Files
+```
+email/src/
+├── index.ts          # All exports
+├── email.ts          # Email class + Mail singleton
+├── template.ts       # Template rendering engine
+├── types.ts          # Types and interfaces
+├── sdk/index.ts      # EmailSDK (send + inbox management)
+└── drivers/
+    ├── base.ts       # BaseEmailDriver abstract class
+    ├── ses.ts        # AWS SES driver
+    ├── sendgrid.ts   # SendGrid driver
+    ├── mailgun.ts    # Mailgun driver
+    ├── mailtrap.ts   # Mailtrap driver (sandbox/production)
+    └── smtp.ts       # Raw SMTP driver (TLS/STARTTLS)
+```
+
+## Mail Singleton
+
+```typescript
+import { mail } from '@stacksjs/email'
+
+await mail.send({
+  from: { name: 'App', address: 'noreply@app.com' },
+  to: 'user@example.com',
+  subject: 'Welcome',
+  html: '<h1>Hello!</h1>',
+  text: 'Hello!'
+})
+
+// Switch driver
+const sendgridMail = mail.use('sendgrid')
+await sendgridMail.send(message)
+```
+
+## Email Class
+
+```typescript
+const email = new Email({
+  name: 'WelcomeEmail',
+  subject: 'Welcome!',
+  to: 'user@example.com',
+  from: { name: 'App', address: 'noreply@app.com' },
+  template: 'welcome',     // looks for welcome.stx or welcome.html
+  handle: async () => ({ message: 'sent' }),
+  onError: async (err) => ({ message: err.message }),
+  onSuccess: () => console.log('Sent!')
+})
+
+const html = await email.renderTemplate()
+await email.send()
+await email.send('override@email.com')
+```
+
+## Template Rendering
+
+```typescript
+import { template, renderHtml, templateExists, listTemplates } from '@stacksjs/email'
+
+const { html, text } = await template('welcome', {
+  variables: { name: 'John', url: 'https://app.com' },
+  layout: 'default',   // or false to skip layout
+  subject: 'Welcome'
+})
+
+// Raw HTML rendering
+const { html, text } = renderHtml('<h1>Hello {{name}}</h1>', { name: 'World' })
+
+templateExists('welcome')   // boolean
+listTemplates()              // string[]
+```
+
+Variable interpolation uses `{{ variable }}` syntax. Templates can be `.stx` (processed by STX engine) or `.html`.
+
+## EmailSDK (Inbox Management via S3)
+
+```typescript
+import { emailSDK, sendEmail, getInbox, searchEmails, deleteEmail } from '@stacksjs/email'
+
+// Send
+await sendEmail({ from: { address: 'a@b.com' }, to: 'c@d.com', subject: 'Hi', html: '<p>Hello</p>' })
+
+// Send with template
+await emailSDK.sendTemplate({ to: 'user@example.com', templateName: 'welcome', data: { name: 'John' } })
+
+// Read inbox (from S3)
+const emails = await getInbox('chris', { limit: 20 })
+const email = await emailSDK.getEmail('chris', messageId)
+
+// Search
+const results = await searchEmails('chris', { from: 'boss', after: '2024-01-01', hasAttachments: true })
+
+// Manage
+await emailSDK.markAsRead('chris', messageId)
+await emailSDK.markAsUnread('chris', messageId)
+await deleteEmail('chris', messageId)
+```
+
+## Built-in Drivers
+
+### SES Driver
+- Uses `@aws-sdk/client-ses` SESClient
+- Lazy-loads client on first send
+- Supports `Source` formatting: `"Name" <address>`
+
+### SendGrid Driver
+- API key from config/env
+- Multipart content (HTML + text)
+- Attachment support (base64 encoding)
+- Retry with exponential backoff
+
+### Mailgun Driver
+- FormData construction with recipients
+- CC/BCC support
+- Attachment handling via FormData
+- Configurable domain and endpoint
+
+### Mailtrap Driver
+- Inbox-aware sending
+- Sandbox and production modes
+- Host default: `sandbox.api.mailtrap.io`
+
+### SMTP Driver
+- Raw TCP/TLS socket connection
+- STARTTLS upgrade support
+- AUTH LOGIN authentication
+- MIME multipart (text + HTML)
+- 30-second connection timeout
+- Command queue-based protocol
+
+## Driver Interface
+
+```typescript
+abstract class BaseEmailDriver {
+  abstract name: string
+  abstract send(message: EmailMessage, options?: TemplateOptions): Promise<EmailResult>
+  protected validateMessage(message): boolean
+  protected formatAddresses(...): string[]
+  protected handleError(error, message): Promise<EmailResult>
+  protected handleSuccess(message, messageId?): Promise<EmailResult>
+}
+```
+
+## config/email.ts
+
+```typescript
+{
+  from: { name: env.MAIL_FROM_NAME, address: env.MAIL_FROM_ADDRESS },
+  domain: 'stacksjs.com',
+  mailboxes: ['chris', 'blake', 'glenn'],
+  url: env.APP_URL,
+  charset: 'UTF-8',
+  default: 'ses',  // 'ses' | 'sendgrid' | 'mailgun' | 'mailtrap' | 'smtp' | 'postmark'
+  server: {
+    enabled: true,
+    scan: { enabled: true },
+    subdomain: 'mail',
+    mode: 'server',  // 'server' | 'serverless'
+    ports: { smtp: 25, smtps: 465, submission: 587, imap: 143, imaps: 993 },
+    features: { imap: true, pop3: false, webmail: false, calDAV: false },
+    categorization: {
+      enabled: true,
+      social: { domains: ['facebook', 'twitter', ...] },
+      forums: { domains: ['reddit', ...] },
+      updates: { substrings: ['noreply', 'no-reply', ...] },
+      promotions: { substrings: ['unsubscribe', 'promo', ...] }
+    }
+  },
+  notifications: { newEmail: true, bounces: true, complaints: true }
+}
+```
+
+## Application Mail Example
+
+```typescript
+// app/Mail/SubscriptionConfirmation.ts
+export async function sendSubscriptionConfirmation({ to, subscriberUuid }: Options) {
+  const { html, text } = await template('subscription-confirmation', {
+    variables: {
+      unsubscribeUrl: url('email.unsubscribe', { token: subscriberUuid }),
+      appName: config.app.name
+    }
+  })
+
+  await mail.send({
+    from: { name: config.app.name, address: config.email.from.address },
+    to,
+    subject: 'Confirm your subscription',
+    html,
+    text
+  })
+}
+```
+
+## CLI Commands
+- `buddy email` / `buddy mail` — email management
+- `buddy email:verify` — check domain verification
+- `buddy email:test [recipient]` — send test email
+- `buddy email:list` — list mailboxes
+- `buddy email:logs -n 50` — view logs
+- `buddy email:status` — server status
+- `buddy email:inbox [mailbox]` — view inbox from S3
+- `buddy mail:user:add <email>` — add mail user
+- `buddy mail:user:list` — list mail users
+- `buddy mail:user:delete <email>` — delete mail user
+
+## Gotchas
+- Default driver is `ses` — requires AWS credentials
+- Template rendering supports both `.stx` and `.html` files
+- Variable interpolation uses `{{ }}` double-brace syntax
+- The `mail` singleton auto-registers all 5 drivers on initialization
+- SMTP driver handles TLS handshake manually (not via node:tls)
+- SendGrid/Mailgun retry with exponential backoff on failure
+- Mailtrap requires `inboxId` for sandbox mode
+- EmailSDK reads inbox from S3 (bucket configured via env)
+- Email categorization auto-sorts incoming mail by domain/substring patterns
+- The `text` fallback is auto-generated from HTML via `htmlToText()`

package/ai/skills/stacks-enums/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: stacks-enums
+description: Use when working with framework constants in a Stacks application — NpmScript commands, Action identifiers, or any enumerated constants used across the build system, CLI, and actions. Covers @stacksjs/enums.
+license: MIT
+compatibility: Bun >= 1.3.0, TypeScript
+allowed-tools: Read Edit Write Bash Grep Glob
+---
+
+# Stacks Enums
+
+## Key Paths
+- Core package: `storage/framework/core/enums/src/`
+- Source: `storage/framework/core/enums/src/index.ts`
+- Package: `@stacksjs/enums`
+
+## NpmScript Enum (45 values)
+
+Used by the CLI and build system to run specific npm scripts:
+
+```typescript
+import { NpmScript } from '@stacksjs/enums'
+```
+
+### Build Scripts
+| Value | Script |
+|-------|--------|
+| `Build` | `'build'` |
+| `BuildComponents` | `'vite build --config ./src/vite-config/src/components.ts'` |
+| `BuildWebComponents` | `'build:web-components'` |
+| `BuildFunctions` | `'build:functions'` |
+| `BuildDocs` | `'build:docs'` |
+| `BuildStacks` | `'build:stacks'` |
+
+### Dev Scripts
+| Value | Script |
+|-------|--------|
+| `Dev` | `'dev'` |
+| `DevApi` | `'dev:api'` |
+| `DevDocs` | `'dev:docs'` |
+| `DevDesktop` | `'dev:desktop'` |
+| `DevFunctions` | `'dev:functions'` |
+
+### Test Scripts
+| Value | Script |
+|-------|--------|
+| `Test` | `'test'` |
+| `TestUnit` | `'test:unit'` |
+| `TestFeature` | `'test:feature'` |
+| `TestUi` | `'test:ui'` |
+| `TestTypes` | `'test:types'` |
+
+### Maintenance Scripts
+`Clean`, `Fresh`, `Lint`, `LintFix`, `Upgrade`, `Generate`, `GenerateTypes`, `GenerateEntries`, `GenerateWebTypes`, `GenerateIdeHelpers`, `GenerateComponentMeta`, `Commit`, `Release`, `KeyGenerate`, `Preinstall`, `Prepublish`
+
+## Action Enum (60+ values)
+
+Used to dispatch framework actions via the action runner:
+
+```typescript
+import { Action } from '@stacksjs/enums'
+```
+
+### Build Actions
+`BuildViews`, `BuildStacks`, `BuildComponentLibs`, `BuildVueComponentLib`, `BuildWebComponentLib`, `BuildFunctionLib`, `BuildCli`, `BuildCore`, `BuildDesktop`, `BuildDocs`, `BuildServer`
+
+### Dev Actions
+`DevComponents`, `DevDashboard`, `DevSystemTray`, `Dev`, `DevApi`, `DevDesktop`, `DevDocs`
+
+### Database Actions
+`Migrate`, `MigrateFresh`, `MigrateDns`, `Seed`
+
+### Queue Actions
+`QueueTable`, `QueueWork`, `QueueRetry`, `QueueFailed`, `QueueClear`, `QueueStatus`, `QueueFlush`, `QueueMonitor`, `QueueInspect`, `QueueSchedule`, `QueueScheduleList`
+
+### Domain Actions
+`DomainsAdd`, `DomainsPurchase`, `DomainsRemove`
+
+### Search Engine Actions
+`SearchEngineImport`, `SearchEngineFlush`, `SearchEngineListSettings`, `SearchEnginePushSettings`
+
+### Other Actions
+`Lint`, `LintFix`, `Test`, `TestUnit`, `TestFeature`, `TestUi`, `Typecheck`, `Deploy`, `ScheduleRun`, `Release`, `RouteList`, `Upgrade`, `UpgradeDeps`
+
+## Usage
+
+```typescript
+import { Action, NpmScript } from '@stacksjs/enums'
+
+// Used in buddy CLI commands
+runAction(Action.Migrate, options)
+
+// Used in build system
+runNpmScript(NpmScript.BuildComponents)
+```
+
+## Gotchas
+- **Action values use path format** — e.g., `Action.BuildViews = 'build/views'`, `Action.QueueWork = 'queue/work'`
+- **NpmScript values are actual script commands** — some are full vite commands, not just script names
+- **Used throughout the framework** — CLI, build system, and actions all reference these enums
+- **Adding new actions** — requires adding the enum value AND creating the action handler file

package/ai/skills/stacks-env/SKILL.md

@@ -0,0 +1,181 @@
+---
+name: stacks-env
+description: Use when working with environment variables in Stacks — the typed env proxy with auto-coercion, .env file loading, AES-256-GCM encryption/decryption of env values, runtime/platform detection, CI provider detection, or the env CLI commands. Covers @stacksjs/env, config/env.ts, and .env files.
+license: MIT
+compatibility: Bun >= 1.3.0, TypeScript
+allowed-tools: Read Edit Write Bash Grep Glob
+---
+
+# Stacks Environment
+
+## Key Paths
+- Core package: `storage/framework/core/env/src/`
+- Environment config: `config/env.ts`
+- Environment file: `.env`
+- Example: `.env.example`
+- Type definitions: `storage/framework/env.d.ts`
+
+## Source Files
+```
+env/src/
+├── index.ts     # main exports
+├── utils.ts     # runtime/platform detection, StacksEnv proxy
+├── plugin.ts    # Bun plugin for auto .env loading
+├── parser.ts    # .env file parser with encryption support
+├── cli.ts       # CLI commands (get, set, encrypt, decrypt, rotate)
+├── crypto.ts    # AES-256-GCM + secp256k1 encryption
+└── types.ts     # StacksEnv interface (100+ typed vars)
+```
+
+## Typed Environment Proxy
+
+```typescript
+import { env } from '@stacksjs/env'
+
+env.APP_NAME        // string
+env.APP_ENV         // 'local' | 'dev' | 'stage' | 'prod'
+env.APP_KEY         // string
+env.APP_URL         // string
+env.DEBUG           // boolean (auto-coerced)
+env.PORT            // number (auto-coerced)
+env.DB_CONNECTION   // 'sqlite' | 'mysql' | 'postgres' | 'dynamodb'
+env.DB_HOST         // string
+env.DB_PORT         // number
+env.DB_DATABASE     // string
+env.DB_USERNAME     // string
+env.DB_PASSWORD     // string
+env.AWS_ACCESS_KEY_ID    // string
+env.STRIPE_SECRET_KEY    // string
+env.MAIL_MAILER          // string
+env.QUEUE_DRIVER         // string
+env.REDIS_HOST           // string
+env[key]                 // any custom env var
+```
+
+The `env` proxy auto-coerces: `'true'` → `true`, `'123'` → `123`, etc.
+
+## StacksEnv Type (100+ typed variables)
+App, Ports, API, Database, AWS, Mail, Services (Stripe, Meilisearch), Frontend, Realtime, Redis, Pusher, Auth, Storage, Queue, plus `[key: string]` catch-all.
+
+## Runtime Detection
+
+```typescript
+import { isBun, isNode, runtime, runtimeInfo, platform, isWindows, isMacOS, isLinux, hasTTY, hasWindow, isCI, isDebug, isMinimal, isColorSupported, provider, providerInfo } from '@stacksjs/env'
+
+isBun           // true
+isNode          // false
+runtime         // 'bun'
+platform        // 'darwin'
+isWindows       // false
+isMacOS         // true
+isLinux         // false
+hasTTY          // true (terminal)
+isCI            // false
+isDebug         // boolean
+isColorSupported // true
+```
+
+## CI Provider Detection
+
+```typescript
+provider        // 'github-actions' | 'gitlab-ci' | 'circleci' | 'travis' | 'jenkins' | 'vercel' | 'netlify' | 'heroku' | 'aws' | 'azure' | 'cloudflare' | 'railway' | 'render' | ...
+providerInfo    // { name: string, ... }
+```
+
+## .env File Loading
+
+```typescript
+import { loadEnv, autoLoadEnv, envPlugin } from '@stacksjs/env'
+
+await loadEnv({ path: '.env', override: false })
+autoLoadEnv()  // detects .env, .env.local, .env.{APP_ENV}
+
+// Bun plugin (auto-loads .env before app starts)
+envPlugin()
+```
+
+## .env Parser
+
+```typescript
+import { parse } from '@stacksjs/env'
+
+const vars = parse(envContent, {
+  encryption: true,       // decrypt encrypted values
+  privateKey: '...'       // decryption key
+})
+```
+
+## Encryption (AES-256-GCM)
+
+```typescript
+import { aesEncrypt, aesDecrypt, generateKeypair, encryptValue, decryptValue, getPrivateKey } from '@stacksjs/env'
+
+// AES-256-GCM symmetric encryption
+const encrypted = aesEncrypt(plaintext, password)
+const decrypted = aesDecrypt(encrypted, password)
+
+// Asymmetric encryption (secp256k1 ECIES-style)
+const keypair = generateKeypair()
+const encrypted = encryptValue(value, keypair.publicKey)
+const decrypted = decryptValue(encrypted, keypair.privateKey)
+```
+
+## CLI Commands
+
+```bash
+buddy env:get APP_NAME                    # get single var
+buddy env:get --all --format json         # all vars as JSON
+buddy env:set APP_NAME "My App"           # set var
+buddy env:encrypt                          # encrypt .env file
+buddy env:decrypt                          # decrypt .env file
+buddy env:keypair                          # generate encryption keypair
+buddy env:rotate                           # rotate encryption keys
+buddy env:check                            # validate env configuration
+buddy env:check --file .env.production     # check a specific environment's file
+```
+
+## Tenant isolation on a shared box
+
+When several projects share one server - one owns it, the rest attach with
+`cloud.attachTo` - each still deploys from its own repository with its own
+`.env.<environment>`. No project needs another's values.
+
+They leak anyway: a tenant's secrets get pasted into the owner's env file under
+a `TENANT_` prefix while debugging a deploy, and stay. That is not just untidy.
+`buddy deploy` ships the whole env file as **every** site's `.env` (ts-cloud
+treats `site.env` as the complete file), so a stray `BUGHQ_STRIPE_SECRET_KEY` in
+the owner's file lands on disk in an unrelated site.
+
+Declare who is attached, in `config/cloud.ts`'s default export:
+
+```typescript
+const config: CloudConfig = {
+  tenants: ['bughq', 'analyticshq'],
+}
+```
+
+With that:
+
+- `buddy deploy` drops those keys before shipping, and logs what it dropped
+- `buddy env:check` lists them per tenant so they can be deleted at source
+
+Prefixes are **never** inferred. With no `tenants` declared nothing is treated
+as foreign, because `STRIPE_`, `AWS_` and `MEILISEARCH_` are indistinguishable
+from a slug prefix by shape alone. Slug punctuation is ignored, so
+`analytics-hq` and `analytics_hq` both match `ANALYTICSHQ_`.
+
+The API is `partitionTenantEnv(values, { self, tenants })` from
+`@stacksjs/env`, plus `stripForeignTenantEnv` and `foreignTenantKeys`.
+
+## Gotchas
+- **A tenant's keys in your env file get shipped everywhere.** `buddy deploy`
+  sends the entire env file as each site's `.env`. Declare `tenants` in
+  `config/cloud.ts` so they are stripped, then delete them at source
+- Bun natively loads `.env` — no dotenv package needed
+- The `env` proxy auto-coerces strings to booleans/numbers
+- `.env` should never be committed — use `.env.example` as template
+- Encryption uses AES-256-GCM for values and secp256k1 for key exchange
+- `autoLoadEnv()` loads in order: `.env`, `.env.local`, `.env.{APP_ENV}`
+- Runtime detection uses Bun globals and process properties
+- CI provider detection checks environment variables specific to each CI system
+- The `StacksEnv` type provides autocomplete for 100+ known variables

package/ai/skills/stacks-error-handling/SKILL.md

@@ -0,0 +1,137 @@
+---
+name: stacks-error-handling
+description: Use when implementing error handling in Stacks — the Result type (Ok/Err), handleError function, error page rendering (development with stack traces, production with friendly messages), ErrorHandler class, ModelNotFoundException, HTTP error mapping, log file writing, or error configuration. Covers @stacksjs/error-handling and config/errors.ts.
+license: MIT
+compatibility: Bun >= 1.3.0, TypeScript
+allowed-tools: Read Edit Write Bash Grep Glob
+---
+
+# Stacks Error Handling
+
+Type-safe error handling with Result types, error pages, and structured logging.
+
+## Key Paths
+- Core package: `storage/framework/core/error-handling/src/`
+- Configuration: `config/errors.ts`
+- Error model: `storage/framework/defaults/app/Models/Error.ts`
+
+## Result Type (from ts-error-handling)
+
+```typescript
+import { ok, err, fromPromise } from '@stacksjs/error-handling'
+import type { Result, Ok, Err, ResultAsync } from '@stacksjs/error-handling'
+
+// Create results
+const success: Ok<string> = ok('data')
+const failure: Err<Error> = err(new Error('failed'))
+
+// From promises
+const result: ResultAsync<Data, Error> = fromPromise(fetchData())
+
+// Pattern matching
+if (result.isOk()) {
+  console.log(result.value)
+} else {
+  console.error(result.error)
+}
+```
+
+## Error Handler
+
+```typescript
+import { handleError, ErrorHandler } from '@stacksjs/error-handling'
+
+// Function-based
+handleError(error)
+handleError(error, { shouldExit: true })
+
+// Class-based
+ErrorHandler.handle(error)
+ErrorHandler.handleError(error, { shouldExit: true })
+ErrorHandler.writeErrorToFile(error)
+ErrorHandler.writeErrorToConsole(error)
+```
+
+## Log File Writing
+
+```typescript
+import { writeToLogFile, setLogPath } from '@stacksjs/error-handling'
+
+setLogPath('/custom/log/path')
+await writeToLogFile('Error message', { path: '/custom/path' })
+```
+
+Default log path: `storage/logs/stacks.log`
+
+## Error Page Rendering
+
+```typescript
+import { ErrorPageHandler, renderError, renderErrorPage, renderProductionErrorPage, createErrorHandler, errorResponse } from '@stacksjs/error-handling'
+
+// Development: shows stack trace, source code, file paths
+const devPage = renderErrorPage(error, request)
+
+// Production: friendly error message, no internals
+const prodPage = renderProductionErrorPage(error, request)
+
+// Auto-detect environment
+const page = renderError(error, request)
+
+// Create handler for routes
+const handler = createErrorHandler()
+const response = errorResponse(error, request)
+```
+
+## HTTP Error Mapping
+
+```typescript
+import { HTTP_ERRORS } from '@stacksjs/error-handling'
+
+// Maps status codes to error details
+HTTP_ERRORS[400]  // { title: 'Bad Request', ... }
+HTTP_ERRORS[401]  // { title: 'Unauthorized', ... }
+HTTP_ERRORS[403]  // { title: 'Forbidden', ... }
+HTTP_ERRORS[404]  // { title: 'Not Found', ... }
+HTTP_ERRORS[500]  // { title: 'Internal Server Error', ... }
+```
+
+## Custom Exceptions
+
+```typescript
+import { ModelNotFoundException } from '@stacksjs/error-handling'
+
+throw new ModelNotFoundException('User not found')
+```
+
+## Error Page Types
+
+```typescript
+interface HttpError { status: number, title: string, message: string }
+interface StackFrame { file: string, line: number, column: number, function?: string }
+interface CodeSnippet { line: number, code: string, isHighlighted: boolean }
+```
+
+## Error Model (storage/framework/defaults/app/Models/Error.ts)
+
+Fields: type, message, stack (stacktrace), status, additional_info
+Seeder: 10 records for testing
+
+## config/errors.ts
+
+Contains comprehensive validation error messages for all field types:
+- String validation: required, minLength, maxLength, email, url, uuid, etc.
+- Number validation: required, min, max, positive, negative, integer, etc.
+- Enum validation: invalid value messages
+- Date validation: format, before, after, etc.
+- File validation: size, type, dimensions, etc.
+
+## Gotchas
+- Use `Result<T, E>` types instead of try/catch for recoverable errors
+- `ok()` and `err()` are from `ts-error-handling` (neverthrow-compatible)
+- Error pages automatically detect environment (dev shows stack traces, prod doesn't)
+- `handleError()` logs to both console and file
+- `ModelNotFoundException` is thrown by `findOrFail()` and `firstOrFail()` ORM methods
+- The Error model persists errors to the database for tracking
+- `config/errors.ts` is a comprehensive i18n-ready error message catalog
+- `ErrorHandler.isTestEnvironment` prevents process exit during tests
+- `ERROR_PAGE_CSS` contains built-in styling for error pages