@stacksjs/error-handling 0.70.22 → 0.70.25

package/dist/src/error-page.d.ts

@@ -0,0 +1,381 @@
+export declare function isFrameworkFrame(file: string): boolean;
+/**
+ * Render a simple production error page
+ */
+export declare function renderProductionErrorPage(status: number): string;
+/**
+ * Render the contextual hint block (common causes, suggestion, doc link)
+ * for a given HTTP status. Returns an empty string for statuses without
+ * enriched data so the dev page degrades gracefully.
+ */
+export declare function renderHttpErrorHints(status: number): string;
+/**
+ * Create an error handler instance
+ */
+export declare function createErrorHandler(config?: ErrorPageConfig): ErrorPageHandler;
+/**
+ * Render an error page (alias)
+ */
+export declare function renderErrorPage(error: Error, status?: number, config?: ErrorPageConfig): string;
+/**
+ * Render error (alias)
+ */
+export declare function renderError(error: Error, status?: number): string;
+/**
+ * Create an error response
+ */
+export declare function errorResponse(error: Error, status?: number, config?: ErrorPageConfig): Response;
+// HTTP error definitions. Each entry includes a doc link, likely causes,
+// and a concrete suggestion so the dev-mode error page reads like a hint
+// instead of just "something went wrong".
+export declare const HTTP_ERRORS: {
+  400: {
+  status: 400;
+  title: 'Bad Request';
+  message: 'The request was malformed or invalid.';
+  docLink: `${DOCS_BASE}/400`;
+  commonCauses: readonly ['JSON body is missing or has a syntax error', 'A required field is absent from the payload', 'Content-Type header does not match the body format'];
+  suggestion: 'Inspect the request body and Content-Type — most 400s come from malformed JSON or a missing required field.'
+};
+  401: {
+  status: 401;
+  title: 'Unauthorized';
+  message: 'Authentication is required to access this resource.';
+  docLink: `${DOCS_BASE}/401`;
+  commonCauses: readonly ['No Authorization header was sent', 'The bearer token expired', 'The session cookie was cleared'];
+  suggestion: 'Confirm a valid `Authorization: Bearer <token>` header is sent and the token has not expired.'
+};
+  403: {
+  status: 403;
+  title: 'Forbidden';
+  message: 'You do not have permission to access this resource.';
+  docLink: `${DOCS_BASE}/403`;
+  commonCauses: readonly ['The authenticated user lacks the required ability or role', 'A Gate or policy denied access (see app/Gates.ts)', 'The token was issued without the needed ability'];
+  suggestion: 'Check Gates / policies and the abilities encoded in the access token.'
+};
+  404: {
+  status: 404;
+  title: 'Not Found';
+  message: 'The requested resource could not be found.';
+  docLink: `${DOCS_BASE}/404`;
+  commonCauses: readonly ['The route is not registered in app/Routes.ts', 'A typo in the URL path', 'A model lookup returned no row (ModelNotFoundError)'];
+  suggestion: 'Run `buddy route:list` to see registered routes, or verify the model exists with the given id.'
+};
+  405: {
+  status: 405;
+  title: 'Method Not Allowed';
+  message: 'The request method is not supported for this resource.';
+  docLink: `${DOCS_BASE}/405`;
+  commonCauses: readonly ['The route is registered for a different HTTP method', 'A form posted GET when the route expects POST'];
+  suggestion: 'Confirm the HTTP method in `app/Routes.ts` matches what the client sent.'
+};
+  408: {
+  status: 408;
+  title: 'Request Timeout';
+  message: 'The request took too long to complete.';
+  docLink: `${DOCS_BASE}/408`;
+  commonCauses: readonly ['A long-running query or external API call exceeded the timeout', 'The client uploaded a slow body that stalled'];
+  suggestion: 'Move slow work into a queued job, or raise the route timeout if the work is genuinely long.'
+};
+  409: {
+  status: 409;
+  title: 'Conflict';
+  message: 'The request conflicts with the current state of the resource.';
+  docLink: `${DOCS_BASE}/409`;
+  commonCauses: readonly ['A unique-constraint violation (duplicate email, slug, etc.)', 'Optimistic locking detected a stale write'];
+  suggestion: 'Re-fetch the resource and retry, or surface the conflict to the user.'
+};
+  410: {
+  status: 410;
+  title: 'Gone';
+  message: 'The requested resource is no longer available.';
+  docLink: `${DOCS_BASE}/410`;
+  commonCauses: readonly ['The resource was permanently deleted', 'A signed URL expired'];
+  suggestion: 'Issue a fresh signed URL or fall back to the canonical resource.'
+};
+  422: {
+  status: 422;
+  title: 'Unprocessable Entity';
+  message: 'The request was well-formed but could not be processed.';
+  docLink: `${DOCS_BASE}/422`;
+  commonCauses: readonly ['Validation rules from the action / model rejected the payload', 'A field value is outside the allowed range or shape'];
+  suggestion: 'Inspect `errors` in the response body — each key maps to a failing field.'
+};
+  429: {
+  status: 429;
+  title: 'Too Many Requests';
+  message: 'You have exceeded the rate limit.';
+  docLink: `${DOCS_BASE}/429`;
+  commonCauses: readonly ['Rate-limit middleware tripped on this IP / token', 'A retry loop is hammering the endpoint'];
+  suggestion: 'Honor the `Retry-After` response header and back off before retrying.'
+};
+  500: {
+  status: 500;
+  title: 'Internal Server Error';
+  message: 'An unexpected error occurred on the server.';
+  docLink: `${DOCS_BASE}/500`;
+  commonCauses: readonly ['An unhandled exception in an action or middleware', 'A failing database connection or migration', 'A misconfigured environment variable'];
+  suggestion: 'Check server logs for the original stack trace — the error page above shows the throw site in dev.'
+};
+  502: {
+  status: 502;
+  title: 'Bad Gateway';
+  message: 'The server received an invalid response from an upstream server.';
+  docLink: `${DOCS_BASE}/502`;
+  commonCauses: readonly ['An upstream HTTP API returned a malformed response', 'A reverse proxy could not reach the origin'];
+  suggestion: 'Verify the upstream service is healthy and returning the expected content type.'
+};
+  503: {
+  status: 503;
+  title: 'Service Unavailable';
+  message: 'The service is temporarily unavailable.';
+  docLink: `${DOCS_BASE}/503`;
+  commonCauses: readonly ['Maintenance mode is enabled', 'A health check is failing', 'A dependency (db, redis, queue) is down'];
+  suggestion: 'Run `buddy doctor` and check dependent services.'
+};
+  504: {
+  status: 504;
+  title: 'Gateway Timeout';
+  message: 'The upstream server did not respond in time.';
+  docLink: `${DOCS_BASE}/504`;
+  commonCauses: readonly ['An upstream HTTP call exceeded its deadline', 'A long-running database query timed out'];
+  suggestion: 'Move the work to a queued job or raise the upstream timeout if the latency is expected.'
+}
+};
+// CSS for error pages
+export declare const ERROR_PAGE_CSS: `
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+    line-height: 1.6;
+    color: #1a1a2e;
+    background: #f8f9fa;
+  }
+  .dark body { background: #1a1a2e; color: #e8e8e8; }
+  .container { max-width: 1200px; margin: 0 auto; padding: 2rem; }
+  .error-header {
+    background: linear-gradient(135deg, #dc3545 0%, #c82333 100%);
+    color: white;
+    padding: 2rem;
+    border-radius: 12px;
+    margin-bottom: 1.5rem;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+  }
+  .error-title { font-size: 1.5rem; font-weight: 600; margin-bottom: 0.5rem; }
+  .error-message { font-size: 1.1rem; opacity: 0.9; word-break: break-word; }
+  .error-status { font-size: 0.875rem; opacity: 0.75; margin-top: 0.5rem; }
+  .card {
+    background: white;
+    border-radius: 12px;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+    margin-bottom: 1.5rem;
+    overflow: hidden;
+  }
+  .dark .card { background: #252540; }
+  .card-header {
+    padding: 1rem 1.5rem;
+    border-bottom: 1px solid #e9ecef;
+    font-weight: 600;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+  }
+  .dark .card-header { border-bottom-color: #3a3a5a; }
+  .card-body { padding: 1.5rem; }
+  .stack-frame {
+    padding: 1rem 1.5rem;
+    border-bottom: 1px solid #e9ecef;
+    cursor: pointer;
+    transition: background 0.2s;
+  }
+  .stack-frame:hover { background: #f8f9fa; }
+  .dark .stack-frame:hover { background: #1a1a2e; }
+  .stack-frame:last-child { border-bottom: none; }
+  .stack-frame.expanded { background: #f8f9fa; }
+  .dark .stack-frame.expanded { background: #1a1a2e; }
+  .frame-file { font-family: 'Monaco', 'Menlo', monospace; font-size: 0.875rem; color: #6c757d; }
+  .frame-function { font-weight: 500; color: #495057; }
+  .dark .frame-function { color: #e8e8e8; }
+  .frame-line { color: #dc3545; font-weight: 600; }
+  .code-snippet {
+    background: #282c34;
+    color: #abb2bf;
+    padding: 1rem;
+    margin-top: 0.5rem;
+    border-radius: 8px;
+    overflow-x: auto;
+    font-family: 'Monaco', 'Menlo', monospace;
+    font-size: 0.8125rem;
+    line-height: 1.8;
+  }
+  .code-line { display: flex; }
+  .code-line-number {
+    width: 3rem;
+    text-align: right;
+    padding-right: 1rem;
+    color: #636d83;
+    user-select: none;
+  }
+  .code-line-content { flex: 1; }
+  .code-line.highlight { background: rgba(220, 53, 69, 0.2); }
+  .code-line.highlight .code-line-number { color: #dc3545; }
+  .info-table { width: 100%; border-collapse: collapse; }
+  .info-table td { padding: 0.75rem 0; border-bottom: 1px solid #e9ecef; }
+  .dark .info-table td { border-bottom-color: #3a3a5a; }
+  .info-table td:first-child { font-weight: 500; width: 30%; color: #6c757d; }
+  .info-table tr:last-child td { border-bottom: none; }
+  .query-item {
+    padding: 1rem;
+    background: #f8f9fa;
+    border-radius: 8px;
+    margin-bottom: 0.75rem;
+    font-family: 'Monaco', 'Menlo', monospace;
+    font-size: 0.8125rem;
+  }
+  .dark .query-item { background: #1a1a2e; }
+  .query-time { color: #6c757d; font-size: 0.75rem; margin-top: 0.5rem; }
+  .badge {
+    display: inline-block;
+    padding: 0.25rem 0.5rem;
+    border-radius: 4px;
+    font-size: 0.75rem;
+    font-weight: 500;
+  }
+  .badge-method { background: #e7f5ff; color: #1971c2; }
+  .dark .badge-method { background: #1971c2; color: white; }
+  .production-page {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    min-height: 100vh;
+    text-align: center;
+    padding: 2rem;
+  }
+  .production-status { font-size: 6rem; font-weight: 700; color: #dee2e6; margin-bottom: 1rem; }
+  .production-title { font-size: 1.5rem; font-weight: 600; margin-bottom: 0.5rem; }
+  .production-message { color: #6c757d; margin-bottom: 2rem; }
+  .production-link { color: #0d6efd; text-decoration: none; }
+  .production-link:hover { text-decoration: underline; }
+  .error-hint {
+    border-left: 4px solid #f59f00;
+    background: #fff9db;
+  }
+  .dark .error-hint, .auto .error-hint { background: #2b2410; border-left-color: #f59f00; }
+  .error-hint .card-header { color: #845200; }
+  .dark .error-hint .card-header, .auto .error-hint .card-header { color: #ffd43b; }
+  .error-hint-causes { margin: 0 0 0.75rem 1.25rem; padding: 0; }
+  .error-hint-causes li { margin: 0.2rem 0; }
+  .error-hint-suggestion { font-weight: 500; margin-bottom: 0.75rem; }
+  .error-hint-doc { color: #0d6efd; text-decoration: none; }
+  .error-hint-doc:hover { text-decoration: underline; }
+  @media (prefers-color-scheme: dark) {
+    .auto body { background: #1a1a2e; color: #e8e8e8; }
+    .auto .card { background: #252540; }
+    .auto .card-header { border-bottom-color: #3a3a5a; }
+    .auto .stack-frame:hover { background: #1a1a2e; }
+    .auto .stack-frame.expanded { background: #1a1a2e; }
+    .auto .frame-function { color: #e8e8e8; }
+    .auto .info-table td { border-bottom-color: #3a3a5a; }
+    .auto .query-item { background: #1a1a2e; }
+    .auto .badge-method { background: #1971c2; color: white; }
+  }
+`;
+/**
+ * Error Page Rendering - Ignition-style error pages
+ *
+ * Provides beautiful development error pages with full stack traces,
+ * database queries, and request context.
+ */
+// Types
+export declare interface ErrorPageConfig {
+  appName?: string
+  theme?: 'light' | 'dark' | 'auto'
+  showEnvironment?: boolean
+  showQueries?: boolean
+  showRequest?: boolean
+  enableCopyMarkdown?: boolean
+  snippetLines?: number
+  basePaths?: string[]
+  showFrameworkFrames?: boolean
+}
+export declare interface RequestContext {
+  method: string
+  url: string
+  headers: Record<string, string>
+  queryParams?: Record<string, string>
+  body?: unknown
+}
+export declare interface RoutingContext {
+  controller?: string
+  routeName?: string
+  middleware?: string[]
+}
+export declare interface UserContext {
+  id?: string | number
+  email?: string
+  name?: string
+}
+export declare interface QueryInfo {
+  query: string
+  time?: number
+  connection?: string
+}
+export declare interface StackFrame {
+  file: string
+  line: number
+  column?: number
+  function?: string
+  code?: string
+}
+export declare interface CodeSnippet {
+  file: string
+  line: number
+  code: string[]
+  highlight: number
+}
+export declare interface EnvironmentContext {
+  nodeVersion?: string
+  platform?: string
+  arch?: string
+  env?: Record<string, string>
+}
+export declare interface JobContext {
+  name?: string
+  queue?: string
+  attempts?: number
+}
+export declare interface ErrorPageData {
+  error: Error
+  status: number
+  stack: StackFrame[]
+  request?: RequestContext
+  routing?: RoutingContext
+  user?: UserContext
+  queries?: QueryInfo[]
+  environment?: EnvironmentContext
+  job?: JobContext
+  framework?: { name: string, version?: string }
+}
+export declare interface HttpError {
+  status: HttpStatusCode
+  title: string
+  message: string
+  docLink?: string
+  commonCauses?: string[]
+  suggestion?: string
+}
+export type HttpStatusCode = 400 | 401 | 403 | 404 | 405 | 408 | 409 | 410 | 422 | 429 | 500 | 502 | 503 | 504;
+/**
+ * Error Page Handler class
+ */
+export declare class ErrorPageHandler {
+  constructor(config?: ErrorPageConfig);
+  setFramework(name: string, version?: string): this;
+  setRequest(request: Request | RequestContext): this;
+  setRouting(routing: RoutingContext): this;
+  setUser(user: UserContext): this;
+  addQuery(query: string, time?: number, connection?: string): this;
+  render(error: Error, status?: number): string;
+  handleError(error: Error, status?: number): Response;
+}

package/dist/src/handler.d.ts

@@ -0,0 +1,30 @@
+import * as path from '@stacksjs/path';
+import type { LogErrorOptions } from '@stacksjs/logging';
+// Function to update the default log path when config is available
+export declare function setLogPath(path: string): void;
+export declare function writeToLogFile(message: string, options?: WriteOptions): Promise<void>;
+export declare function handleError(err: string | Error | object | unknown, options?: LogErrorOptions | Record<string, any>): Error;
+/**
+ * Context information attached to errors for better debugging.
+ */
+export declare interface ErrorContext {
+  requestId?: string
+  url?: string
+  method?: string
+  userId?: string | number
+  ip?: string
+  userAgent?: string
+  [key: string]: unknown
+}
+declare interface WriteOptions {
+  logFile?: string
+}
+declare type ErrorMessage = string;
+export declare class ErrorHandler {
+  static isTestEnvironment: boolean;
+  static shouldExitProcess: boolean;
+  static handle(err: Error | ErrorMessage | unknown, options?: LogErrorOptions): Error;
+  static handleError(err: Error, options?: LogErrorOptions): Error;
+  static writeErrorToFile(err: Error | unknown, context?: ErrorContext): Promise<void>;
+  static writeErrorToConsole(err: string | Error | unknown): void;
+}

package/dist/src/http.d.ts

@@ -0,0 +1,49 @@
+import type { ErrorPageConfig, RequestContext, RoutingContext } from './error-page';
+/**
+ * Create a new HTTP error handler
+ */
+export declare function createHttpErrorHandler(options?: {
+  isDevelopment?: boolean
+  config?: ErrorPageConfig
+}): HttpErrorHandler;
+/**
+ * Quick helper to render an error page for HTTP errors
+ */
+export declare function renderHttpError(error: Error, request?: Request, options?: {
+    status?: number
+    isDevelopment?: boolean
+    config?: ErrorPageConfig
+  }): Response;
+/**
+ * Express/Hono style error middleware
+ */
+export declare function errorMiddleware(options?: {
+  isDevelopment?: boolean
+  config?: ErrorPageConfig
+}): void;
+export declare class HttpError extends Error {
+  details?: unknown;
+  public status: number;
+  constructor(status: number, message: string, details?: unknown);
+}
+/**
+ * HTTP error handler with Ignition-style error pages
+ */
+export declare class HttpErrorHandler {
+  constructor(options?: {
+    isDevelopment?: boolean
+    config?: ErrorPageConfig
+  });
+  setRequest(request: Request | RequestContext): this;
+  setRouting(routing: RoutingContext): this;
+  addQuery(query: string, time?: number, connection?: string): this;
+  handle(error: Error, status?: number): Response;
+  notFound(message?: string): Response;
+  serverError(error: Error): Response;
+  forbidden(message?: string): Response;
+  unauthorized(message?: string): Response;
+  badRequest(message?: string): Response;
+  validationError(message?: string): Response;
+  tooManyRequests(message?: string): Response;
+  serviceUnavailable(message?: string): Response;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,42 @@
+// Result type exports
+export type {
+  Err,
+  Ok,
+  Result,
+  ResultAsync,
+} from 'ts-error-handling';
+// Error page exports (Ignition-style) - local implementation
+export type {
+  CodeSnippet,
+  EnvironmentContext,
+  ErrorPageConfig,
+  ErrorPageData,
+  HttpError as HttpErrorInfo,
+  HttpStatusCode,
+  JobContext,
+  QueryInfo,
+  RequestContext,
+  RoutingContext,
+  StackFrame,
+  UserContext,
+} from './error-page';
+export * from './handler';
+export * from './http';
+export * from './model';
+export * from './utils';
+export {
+  err,
+  fromPromise,
+  ok,
+} from 'ts-error-handling';
+export {
+  createErrorHandler,
+  ERROR_PAGE_CSS,
+  ErrorPageHandler,
+  errorResponse,
+  HTTP_ERRORS,
+  renderError,
+  renderErrorPage,
+  renderHttpErrorHints,
+  renderProductionErrorPage,
+} from './error-page';

package/dist/src/model.d.ts

@@ -0,0 +1,4 @@
+export declare class ModelNotFoundException extends Error {
+  public status: number;
+  constructor(status: number, message: string);
+}

package/dist/src/utils.d.ts

@@ -0,0 +1 @@
+export declare function rescue<T, F>(fn: () => T | Promise<T>, fallback: F, onError?: (error: Error) => void): T | F | Promise<T | F>;

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@stacksjs/error-handling",
   "type": "module",
-  "version": "0.70.22",
+  "version": "0.70.25",
   "description": "Type safe error handling.",
   "author": "Chris Breuer",
-  "contributors": ["Chris Breuer <chris@stacksjs.org>"],
+  "contributors": [
+    "Chris Breuer <chris@stacksjs.com>"
+  ],
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
   "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/error-handling#readme",
@@ -16,9 +18,17 @@
   "bugs": {
     "url": "https://github.com/stacksjs/stacks/issues"
   },
-  "keywords": ["errors", "error-handling", "neverthrow", "type safe", "stacks"],
+  "keywords": [
+    "errors",
+    "error-handling",
+    "neverthrow",
+    "type safe",
+    "stacks"
+  ],
   "exports": {
     ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
     "./*": {
@@ -27,19 +37,25 @@
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["README.md", "dist"],
+  "files": [
+    "README.md",
+    "dist"
+  ],
   "scripts": {
     "build": "bun build.ts",
     "typecheck": "bun tsc --noEmit",
     "prepublishOnly": "bun run build"
   },
+  "dependencies": {
+    "ts-error-handling": "^0.1.1"
+  },
   "devDependencies": {
-    "@stacksjs/cli": "0.70.18",
-    "@stacksjs/config": "0.70.18",
-    "@stacksjs/development": "0.70.18",
-    "@stacksjs/path": "0.70.18",
-    "@stacksjs/types": "0.70.18",
-    "@stacksjs/validation": "0.70.18",
-    "neverthrow": "^8.2.0"
-  }
+    "@stacksjs/cli": "0.70.23",
+    "@stacksjs/config": "0.70.23",
+    "better-dx": "^0.2.12",
+    "@stacksjs/path": "0.70.23",
+    "@stacksjs/types": "0.70.23",
+    "@stacksjs/validation": "0.70.23"
+  },
+  "sideEffects": false
 }

package/dist/handler.d.ts

@@ -1,93 +0,0 @@
-import type { ErrorOptions } from '@stacksjs/logging';
-
-declare type ErrorMessage = string
-
-export class ErrorHandler {
-  static isTestEnvironment = false
-  static shouldExitProcess = true
-
-  static handle(err: Error | ErrorMessage | unknown, options?: ErrorOptions): Error {
-    this.shouldExitProcess = options?.shouldExit !== false
-    if (options?.silent !== true)
-      this.writeErrorToConsole(err)
-
-    let errorMessage: string
-
-    if (options?.message) {
-      errorMessage = options.message
-    }
-    else if (err instanceof Error) {
-      errorMessage = err.message
-    }
-    else if (typeof err === 'string') {
-      errorMessage = err
-    }
-    else {
-      errorMessage = JSON.stringify(err)
-    }
-
-    const error = new Error(errorMessage)
-
-    if (err instanceof Error) {
-      Object.assign(error, err)
-    }
-
-    this.writeErrorToFile(error).catch(e => console.error(e))
-
-    return error
-  }
-
-  static handleError(err: Error, options?: ErrorOptions): Error {
-    this.handle(err, options)
-    return err
-  }
-
-  static async writeErrorToFile(err: Error | unknown): Promise<void> {
-    if (!(err instanceof Error)) {
-      console.error('Error is not an instance of Error:', err)
-      return
-    }
-
-    const formattedError = `[${new Date().toISOString()}] ${err.name}: ${err.message}\n`
-    const logFilePath = path.logsPath('stacks.log') ?? path.logsPath('errors.log')
-
-    try {
-      await mkdir(path.dirname(logFilePath), { recursive: true })
-      await appendFile(logFilePath, formattedError)
-    }
-    catch (error) {
-      console.error('Failed to write to error file:', error)
-    }
-  }
-
-  static writeErrorToConsole(err: string | Error | unknown): void {
-    console.error(err)
-
-    const errorString = typeof err === 'string' ? err : err instanceof Error ? err.message : JSON.stringify(err)
-
-    if (
-      errorString.includes('bunx --bun cdk destroy')
-      || errorString === `Failed to execute command: ${italic('bunx --bun eslint . --fix')}`
-      || errorString === `Failed to execute command: ${italic('bun storage/framework/core/actions/src/lint/fix.ts')}`
-    ) {
-      if (!this.isTestEnvironment) {
-        console.log(
-          'No need to worry. The edge function is currently being destroyed. Please run `buddy undeploy` shortly again, and continue doing so until it succeeds running.',
-        )
-        console.log('Hoping to see you back soon!')
-      }
-    }
-
-    if (this.shouldExitProcess) {
-      process.exit(ExitCode.FatalError)
-    }
-  }
-}
-
-interface WriteOptions {
-  logFile?: string
-}
-
-let defaultLogPath = 'storage/logs/stacks.log'
-export declare function setLogPath(path: string): void;
-export declare function handleError(err: string | Error | object | unknown, options?: ErrorOptions | Record<string, any>): Error;

package/dist/http.d.ts

@@ -1,6 +0,0 @@
-export declare class HttpError extends Error {
-  constructor(public status: number, message: string) {
-    super(message)
-    this.name = 'Server Error!'
-  }
-}