@velajs/vela 1.19.0 → 1.19.1

package/dist/errors/http-exception.d.ts

@@ -1,63 +0,0 @@
-export type ExceptionResponse = string | Record<string, unknown>;
-export declare class HttpException extends Error {
-    readonly statusCode: number;
-    private readonly _response;
-    constructor(response: ExceptionResponse, statusCode: number);
-    getStatus(): number;
-    getResponse(): Record<string, unknown>;
-    getRawResponse(): ExceptionResponse;
-}
-export declare class BadRequestException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class UnauthorizedException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class ForbiddenException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class NotFoundException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class MethodNotAllowedException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class NotAcceptableException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class RequestTimeoutException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class ConflictException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class GoneException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class PayloadTooLargeException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class UnsupportedMediaTypeException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class UnprocessableEntityException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class TooManyRequestsException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class InternalServerErrorException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class NotImplementedException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class BadGatewayException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class ServiceUnavailableException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class GatewayTimeoutException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}

package/dist/errors/http-exception.js

@@ -1,142 +0,0 @@
-export class HttpException extends Error {
-    statusCode;
-    _response;
-    constructor(response, statusCode){
-        const message = typeof response === 'string' ? response : JSON.stringify(response);
-        super(message);
-        this.name = 'HttpException';
-        this.statusCode = statusCode;
-        this._response = response;
-        Object.setPrototypeOf(this, new.target.prototype);
-    }
-    getStatus() {
-        return this.statusCode;
-    }
-    getResponse() {
-        if (typeof this._response === 'string') {
-            return {
-                statusCode: this.statusCode,
-                message: this._response
-            };
-        }
-        return this._response;
-    }
-    // The constructor's original argument, untransformed — a string message or a
-    // caller-supplied object. The canonical HTTP edge branches on this: string
-    // responses become `{ error: { code, message } }`, object responses ship
-    // verbatim (crud envelope compat). Distinct from `getResponse()`, which wraps
-    // strings in the legacy `{ statusCode, message }` shape.
-    getRawResponse() {
-        return this._response;
-    }
-}
-// 4xx
-export class BadRequestException extends HttpException {
-    constructor(message = 'Bad Request'){
-        super(message, 400);
-        this.name = 'BadRequestException';
-    }
-}
-export class UnauthorizedException extends HttpException {
-    constructor(message = 'Unauthorized'){
-        super(message, 401);
-        this.name = 'UnauthorizedException';
-    }
-}
-export class ForbiddenException extends HttpException {
-    constructor(message = 'Forbidden'){
-        super(message, 403);
-        this.name = 'ForbiddenException';
-    }
-}
-export class NotFoundException extends HttpException {
-    constructor(message = 'Not Found'){
-        super(message, 404);
-        this.name = 'NotFoundException';
-    }
-}
-export class MethodNotAllowedException extends HttpException {
-    constructor(message = 'Method Not Allowed'){
-        super(message, 405);
-        this.name = 'MethodNotAllowedException';
-    }
-}
-export class NotAcceptableException extends HttpException {
-    constructor(message = 'Not Acceptable'){
-        super(message, 406);
-        this.name = 'NotAcceptableException';
-    }
-}
-export class RequestTimeoutException extends HttpException {
-    constructor(message = 'Request Timeout'){
-        super(message, 408);
-        this.name = 'RequestTimeoutException';
-    }
-}
-export class ConflictException extends HttpException {
-    constructor(message = 'Conflict'){
-        super(message, 409);
-        this.name = 'ConflictException';
-    }
-}
-export class GoneException extends HttpException {
-    constructor(message = 'Gone'){
-        super(message, 410);
-        this.name = 'GoneException';
-    }
-}
-export class PayloadTooLargeException extends HttpException {
-    constructor(message = 'Payload Too Large'){
-        super(message, 413);
-        this.name = 'PayloadTooLargeException';
-    }
-}
-export class UnsupportedMediaTypeException extends HttpException {
-    constructor(message = 'Unsupported Media Type'){
-        super(message, 415);
-        this.name = 'UnsupportedMediaTypeException';
-    }
-}
-export class UnprocessableEntityException extends HttpException {
-    constructor(message = 'Unprocessable Entity'){
-        super(message, 422);
-        this.name = 'UnprocessableEntityException';
-    }
-}
-export class TooManyRequestsException extends HttpException {
-    constructor(message = 'Too Many Requests'){
-        super(message, 429);
-        this.name = 'TooManyRequestsException';
-    }
-}
-// 5xx
-export class InternalServerErrorException extends HttpException {
-    constructor(message = 'Internal Server Error'){
-        super(message, 500);
-        this.name = 'InternalServerErrorException';
-    }
-}
-export class NotImplementedException extends HttpException {
-    constructor(message = 'Not Implemented'){
-        super(message, 501);
-        this.name = 'NotImplementedException';
-    }
-}
-export class BadGatewayException extends HttpException {
-    constructor(message = 'Bad Gateway'){
-        super(message, 502);
-        this.name = 'BadGatewayException';
-    }
-}
-export class ServiceUnavailableException extends HttpException {
-    constructor(message = 'Service Unavailable'){
-        super(message, 503);
-        this.name = 'ServiceUnavailableException';
-    }
-}
-export class GatewayTimeoutException extends HttpException {
-    constructor(message = 'Gateway Timeout'){
-        super(message, 504);
-        this.name = 'GatewayTimeoutException';
-    }
-}

package/dist/errors/index.d.ts

@@ -1 +0,0 @@
-export { HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, GoneException, PayloadTooLargeException, UnsupportedMediaTypeException, UnprocessableEntityException, TooManyRequestsException, InternalServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, GatewayTimeoutException, } from './http-exception';

package/dist/errors/index.js

@@ -1 +0,0 @@
-export { HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, GoneException, PayloadTooLargeException, UnsupportedMediaTypeException, UnprocessableEntityException, TooManyRequestsException, InternalServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, GatewayTimeoutException } from "./http-exception.js";

package/dist/event-emitter/event-emitter.decorators.d.ts

@@ -1 +0,0 @@
-export declare function OnEvent(event: string): MethodDecorator;

package/dist/event-emitter/event-emitter.decorators.js

@@ -1,10 +0,0 @@
-import { MetadataRegistry } from "../registry/metadata.registry.js";
-import { ON_EVENT_METADATA } from "./event-emitter.tokens.js";
-export function OnEvent(event) {
-    return (target, propertyKey)=>{
-        MetadataRegistry.appendCustomClassMeta(target.constructor, ON_EVENT_METADATA, {
-            event,
-            methodName: String(propertyKey)
-        });
-    };
-}

package/dist/event-emitter/event-emitter.module.d.ts

@@ -1,2 +0,0 @@
-export declare class EventEmitterModule {
-}

package/dist/event-emitter/event-emitter.module.js

@@ -1,23 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-import { Module } from "../module/index.js";
-import { EventEmitter } from "./event-emitter.service.js";
-import { EventEmitterSubscriber } from "./event-emitter.subscriber.js";
-export class EventEmitterModule {
-}
-EventEmitterModule = _ts_decorate([
-    Module({
-        lazy: true,
-        providers: [
-            EventEmitter,
-            EventEmitterSubscriber
-        ],
-        exports: [
-            EventEmitter
-        ]
-    })
-], EventEmitterModule);

package/dist/event-emitter/event-emitter.service.d.ts

@@ -1,13 +0,0 @@
-import type { EventHandler } from './event-emitter.types';
-export declare class EventEmitter {
-    private exactListeners;
-    private exactOnceListeners;
-    private wildcardListeners;
-    on(event: string, handler: EventHandler): this;
-    once(event: string, handler: EventHandler): this;
-    off(event: string, handler: EventHandler): this;
-    emit(event: string, ...args: unknown[]): Promise<void>;
-    removeAllListeners(event?: string): this;
-    listenerCount(event: string): number;
-    private getOrCreateWildcard;
-}

package/dist/event-emitter/event-emitter.service.js

@@ -1,127 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-import { Injectable } from "../container/index.js";
-function isWildcard(pattern) {
-    return pattern.includes('*');
-}
-function compilePattern(pattern) {
-    const regexStr = pattern.split('.').map((segment)=>{
-        if (segment === '**') return '.*';
-        if (segment === '*') return '[^.]+';
-        return segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    }).join('\\.');
-    return new RegExp(`^${regexStr}$`);
-}
-export class EventEmitter {
-    exactListeners = new Map();
-    exactOnceListeners = new Map();
-    wildcardListeners = new Map();
-    on(event, handler) {
-        if (isWildcard(event)) {
-            this.getOrCreateWildcard(event).handlers.add(handler);
-        } else {
-            const handlers = this.exactListeners.get(event) ?? new Set();
-            handlers.add(handler);
-            this.exactListeners.set(event, handlers);
-        }
-        return this;
-    }
-    once(event, handler) {
-        this.on(event, handler);
-        if (isWildcard(event)) {
-            this.getOrCreateWildcard(event).onceHandlers.add(handler);
-        } else {
-            const onceSet = this.exactOnceListeners.get(event) ?? new Set();
-            onceSet.add(handler);
-            this.exactOnceListeners.set(event, onceSet);
-        }
-        return this;
-    }
-    off(event, handler) {
-        if (isWildcard(event)) {
-            const entry = this.wildcardListeners.get(event);
-            if (entry) {
-                entry.handlers.delete(handler);
-                entry.onceHandlers.delete(handler);
-                if (entry.handlers.size === 0) this.wildcardListeners.delete(event);
-            }
-        } else {
-            const handlers = this.exactListeners.get(event);
-            if (handlers) {
-                handlers.delete(handler);
-                this.exactOnceListeners.get(event)?.delete(handler);
-                if (handlers.size === 0) this.exactListeners.delete(event);
-            }
-        }
-        return this;
-    }
-    async emit(event, ...args) {
-        const toRemove = [];
-        // Exact match
-        const exactHandlers = this.exactListeners.get(event);
-        if (exactHandlers) {
-            const onceSet = this.exactOnceListeners.get(event);
-            await Promise.all([
-                ...exactHandlers
-            ].map(async (handler)=>{
-                await handler(...args);
-                if (onceSet?.has(handler)) {
-                    toRemove.push(()=>this.off(event, handler));
-                }
-            }));
-        }
-        // Wildcard match (regex pre-compiled at registration)
-        for (const [pattern, entry] of this.wildcardListeners){
-            if (!entry.regex.test(event)) continue;
-            await Promise.all([
-                ...entry.handlers
-            ].map(async (handler)=>{
-                await handler(...args);
-                if (entry.onceHandlers.has(handler)) {
-                    toRemove.push(()=>this.off(pattern, handler));
-                }
-            }));
-        }
-        for (const remove of toRemove)remove();
-    }
-    removeAllListeners(event) {
-        if (event) {
-            if (isWildcard(event)) {
-                this.wildcardListeners.delete(event);
-            } else {
-                this.exactListeners.delete(event);
-                this.exactOnceListeners.delete(event);
-            }
-        } else {
-            this.exactListeners.clear();
-            this.exactOnceListeners.clear();
-            this.wildcardListeners.clear();
-        }
-        return this;
-    }
-    listenerCount(event) {
-        let count = this.exactListeners.get(event)?.size ?? 0;
-        for (const entry of this.wildcardListeners.values()){
-            if (entry.regex.test(event)) count += entry.handlers.size;
-        }
-        return count;
-    }
-    getOrCreateWildcard(pattern) {
-        const existing = this.wildcardListeners.get(pattern);
-        if (existing) return existing;
-        const entry = {
-            regex: compilePattern(pattern),
-            handlers: new Set(),
-            onceHandlers: new Set()
-        };
-        this.wildcardListeners.set(pattern, entry);
-        return entry;
-    }
-}
-EventEmitter = _ts_decorate([
-    Injectable()
-], EventEmitter);

package/dist/event-emitter/event-emitter.subscriber.d.ts

@@ -1,9 +0,0 @@
-import { DiscoveryService } from '../discovery/discovery.service';
-import type { OnApplicationBootstrap } from '../lifecycle/index';
-import { EventEmitter } from './event-emitter.service';
-export declare class EventEmitterSubscriber implements OnApplicationBootstrap {
-    private readonly discovery;
-    private emitter;
-    constructor(discovery: DiscoveryService, emitter: EventEmitter);
-    onApplicationBootstrap(): void;
-}

package/dist/event-emitter/event-emitter.subscriber.js

@@ -1,45 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { Injectable, Inject } from "../container/index.js";
-import { DiscoveryService } from "../discovery/discovery.service.js";
-import { EventEmitter } from "./event-emitter.service.js";
-import { ON_EVENT_METADATA } from "./event-emitter.tokens.js";
-export class EventEmitterSubscriber {
-    discovery;
-    emitter;
-    constructor(discovery, emitter){
-        this.discovery = discovery;
-        this.emitter = emitter;
-    }
-    onApplicationBootstrap() {
-        for (const found of this.discovery.methodsWithMeta(ON_EVENT_METADATA)){
-            const instance = found.class.instance;
-            if (!instance) continue;
-            const method = instance[found.methodName];
-            if (typeof method === 'function') {
-                this.emitter.on(found.meta.event, (...args)=>method.apply(instance, args));
-            }
-        }
-    }
-}
-EventEmitterSubscriber = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Inject(DiscoveryService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
-        typeof EventEmitter === "undefined" ? Object : EventEmitter
-    ])
-], EventEmitterSubscriber);

package/dist/event-emitter/event-emitter.tokens.d.ts

@@ -1 +0,0 @@
-export declare const ON_EVENT_METADATA = "vela:on-event";

package/dist/event-emitter/event-emitter.tokens.js

@@ -1 +0,0 @@
-export const ON_EVENT_METADATA = 'vela:on-event';

package/dist/event-emitter/event-emitter.types.d.ts

@@ -1,5 +0,0 @@
-export type EventHandler = (...args: unknown[]) => void | Promise<void>;
-export interface OnEventMetadata {
-    event: string;
-    methodName: string;
-}

package/dist/event-emitter/event-emitter.types.js

@@ -1 +0,0 @@
-export { };

package/dist/event-emitter/index.d.ts

@@ -1,6 +0,0 @@
-export { EventEmitterModule } from './event-emitter.module';
-export { EventEmitter } from './event-emitter.service';
-export { EventEmitterSubscriber } from './event-emitter.subscriber';
-export { OnEvent } from './event-emitter.decorators';
-export { ON_EVENT_METADATA } from './event-emitter.tokens';
-export type { EventHandler, OnEventMetadata } from './event-emitter.types';

package/dist/event-emitter/index.js

@@ -1,5 +0,0 @@
-export { EventEmitterModule } from "./event-emitter.module.js";
-export { EventEmitter } from "./event-emitter.service.js";
-export { EventEmitterSubscriber } from "./event-emitter.subscriber.js";
-export { OnEvent } from "./event-emitter.decorators.js";
-export { ON_EVENT_METADATA } from "./event-emitter.tokens.js";

package/dist/exceptions/errors.module.d.ts

@@ -1,40 +0,0 @@
-import { type Catalog } from '@velajs/errors';
-import type { Type } from '../container/types';
-import type { ExceptionHandler } from './exception-handler';
-/**
- * Options for {@link ErrorsModule.forRoot}. Both fields are optional — an empty
- * `forRoot()` provides just the core catalog (`CORE_CATALOG`) and no custom
- * handler, which is the framework default anyway.
- */
-export interface ErrorsModuleOptions {
-    /**
-     * App-specific catalogs composed **onto** `CORE_CATALOG` via
-     * {@link composeCatalogs}. Composition is eager (at `forRoot` call time), so a
-     * duplicate code across two catalogs fails fast with `duplicate error code`.
-     */
-    catalogs?: Catalog<string>[];
-    /**
-     * The application-wide {@link ExceptionHandler}. A class is wired with
-     * `useClass` (constructed through DI); a plain handler object with `useValue`.
-     */
-    handler?: Type<ExceptionHandler> | ExceptionHandler;
-}
-declare const ConfigurableModuleClass: import("..").ConfigurableModuleClassType<ErrorsModuleOptions, "forRoot", "create", {
-    isGlobal?: boolean;
-}>;
-/**
- * Registers the application-wide error surface: the composed
- * {@link ERROR_CATALOG} that every transport edge redacts against, and an
- * optional {@link APP_EXCEPTION_HANDLER}. The imperative sibling is
- * `app.useGlobalExceptionHandler(handler)`.
- *
- * ```ts
- * @Module({
- *   imports: [ErrorsModule.forRoot({ catalogs: [ordersCatalog], handler: SentryHandler })],
- * })
- * class AppModule {}
- * ```
- */
-export declare class ErrorsModule extends ConfigurableModuleClass {
-}
-export {};

package/dist/exceptions/errors.module.js

@@ -1,46 +0,0 @@
-import { CORE_CATALOG, composeCatalogs } from "@velajs/errors";
-import { defineModule } from "../module/define-module.js";
-import { APP_EXCEPTION_HANDLER, ERROR_CATALOG } from "../pipeline/tokens.js";
-/** Lower a `handler` option to an {@link APP_EXCEPTION_HANDLER} provider. */ const handlerProvider = (handler)=>typeof handler === 'function' ? {
-        provide: APP_EXCEPTION_HANDLER,
-        useClass: handler
-    } : {
-        provide: APP_EXCEPTION_HANDLER,
-        useValue: handler
-    };
-const { ConfigurableModuleClass } = defineModule({
-    name: 'Errors',
-    setup: ({ options })=>{
-        const providers = [
-            {
-                provide: ERROR_CATALOG,
-                useValue: composeCatalogs(CORE_CATALOG, ...options.catalogs ?? [])
-            }
-        ];
-        const exports = [
-            ERROR_CATALOG
-        ];
-        if (options.handler) {
-            providers.push(handlerProvider(options.handler));
-            exports.push(APP_EXCEPTION_HANDLER);
-        }
-        return {
-            providers,
-            exports
-        };
-    }
-});
-/**
- * Registers the application-wide error surface: the composed
- * {@link ERROR_CATALOG} that every transport edge redacts against, and an
- * optional {@link APP_EXCEPTION_HANDLER}. The imperative sibling is
- * `app.useGlobalExceptionHandler(handler)`.
- *
- * ```ts
- * @Module({
- *   imports: [ErrorsModule.forRoot({ catalogs: [ordersCatalog], handler: SentryHandler })],
- * })
- * class AppModule {}
- * ```
- */ export class ErrorsModule extends ConfigurableModuleClass {
-}

package/dist/exceptions/exception-handler.d.ts

@@ -1,56 +0,0 @@
-import { type ErrorBodyResult } from '@velajs/errors';
-/**
- * A predicate for classifying an error, used by {@link ExceptionHandler.dontReport}.
- *
- * Three shapes are accepted:
- * - `string` — a Vela error code; matches when the error is a branded
- *   `VelaError` whose `code` equals the string.
- * - a predicate `(error: unknown) => boolean` — **must be an arrow function**.
- *   A class and a predicate are both `typeof 'function'`; {@link matchesAny}
- *   discriminates on `prototype`, which arrow functions do not have.
- * - an error class constructor — matches via `instanceof`.
- *
- * Bound functions (e.g. `SomeClass.bind(null)`) also lack `.prototype`, so they
- * are treated as predicates and invoked — never as class matchers. Since a bound
- * constructor cannot be called without `new`, using one here throws; pass the
- * unbound class instead.
- */
-export type ErrorMatcher = string | ((error: unknown) => boolean) | (new (...args: never[]) => Error);
-/**
- * Ambient context handed to every reporting/rendering hook. `edge` names the
- * transport that caught the error; open-ended extra keys (via the index
- * signature) let a handler's `context()` enrich the payload.
- */
-export interface ErrorReportContext {
-    edge: 'http' | 'ws' | 'live' | 'queue' | 'schedule' | 'hono';
-    /** e.g. `'CatsController.findAll'` or a query name. */
-    source?: string;
-    /** e.g. `'exception filter threw'`. */
-    note?: string;
-    [key: string]: unknown;
-}
-/**
- * The application-wide exception handler contract. Provide an implementation
- * under {@link APP_EXCEPTION_HANDLER} to customize how errors are reported and
- * rendered. Every member is optional — an empty object is a valid handler.
- */
-export interface ExceptionHandler {
-    /** Fire-and-forget reporting (logging, Sentry, …). May be async. */
-    report?(error: unknown, ctx: ErrorReportContext): void | Promise<void>;
-    /** Errors matching any of these are never reported. */
-    dontReport?: ErrorMatcher[];
-    /** Extra fields merged into the report context. Must be side-effect free. */
-    context?(error: unknown, ctx: ErrorReportContext): Record<string, unknown>;
-    /** Override the client-bound response for an error. */
-    render?(error: unknown, ctx: unknown): Response | ErrorBodyResult | undefined;
-}
-/**
- * True when `error` matches any of `matchers`. A string matches a branded
- * {@link VelaError} by `code`; an arrow-function predicate is called; anything
- * else with a `prototype` is treated as an error class and matched via
- * `instanceof`. Predicates therefore MUST be arrow functions — a regular
- * `function` expression has a `prototype` and would be mistaken for a class.
- * Bound functions (e.g. `SomeClass.bind(null)`) lack `.prototype` too, so they
- * are invoked as predicates — don't pass a bound class as a class matcher.
- */
-export declare const matchesAny: (matchers: ErrorMatcher[] | undefined, error: unknown) => boolean;

package/dist/exceptions/exception-handler.js

@@ -1,17 +0,0 @@
-import { isVelaError } from "@velajs/errors";
-/**
- * True when `error` matches any of `matchers`. A string matches a branded
- * {@link VelaError} by `code`; an arrow-function predicate is called; anything
- * else with a `prototype` is treated as an error class and matched via
- * `instanceof`. Predicates therefore MUST be arrow functions — a regular
- * `function` expression has a `prototype` and would be mistaken for a class.
- * Bound functions (e.g. `SomeClass.bind(null)`) lack `.prototype` too, so they
- * are invoked as predicates — don't pass a bound class as a class matcher.
- */ export const matchesAny = (matchers, error)=>{
-    if (!matchers?.length) return false;
-    return matchers.some((m)=>{
-        if (typeof m === 'string') return isVelaError(error) && error.code === m;
-        if (typeof m === 'function' && !m.prototype) return m(error);
-        return error instanceof m;
-    });
-};

package/dist/exceptions/index.d.ts

@@ -1,6 +0,0 @@
-export { matchesAny } from './exception-handler';
-export type { ErrorMatcher, ErrorReportContext, ExceptionHandler } from './exception-handler';
-export { ErrorsModule } from './errors.module';
-export type { ErrorsModuleOptions } from './errors.module';
-export { resolveErrorReporter } from './reporter';
-export type { ErrorReporter } from './reporter';

package/dist/exceptions/index.js

@@ -1,3 +0,0 @@
-export { matchesAny } from "./exception-handler.js";
-export { ErrorsModule } from "./errors.module.js";
-export { resolveErrorReporter } from "./reporter.js";