@velajs/errors 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+All notable changes to `@velajs/errors` are documented here. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 1.0.0
+
+Initial release — the unified, zero-dependency error layer for Vela.
+
+### Added
+
+- **`VelaError`** — one framework error class carrying `code`, `status`, `hint`, `docsUrl`, and `data` as own-enumerable properties, so an error rides any wire codec / `structuredClone` / Durable-Object RPC boundary with no special serialization path. Branded with an own-enumerable `type: "VelaError"` discriminator.
+- **Composable catalogs** — `defineErrorCatalog` (typed, keys derive the code union), `composeCatalogs` (merges catalogs and throws on a duplicate code at compose time), the built-in `CORE_CATALOG` (the HTTP status family), and `STATUS_TO_CODE`. Catalog lookups use `Object.hasOwn`, so prototype keys (`toString`, `constructor`, …) are never matched.
+- **`isVelaError`** — a structural, realm-safe, **branded** type guard: `instanceof Error` plus a string `code`, a numeric `status`, and the `VelaError` brand. Survives serialization and the DO↔worker boundary where `instanceof` is unreliable, and a foreign error that merely carries `code`+`status` cannot pass.
+- **`toErrorBody`** — the single wire-redaction seam. Unbranded and internal-coded errors are redacted to a generic message; branded, non-internal errors echo their `message`/`hint`/`details`. Returns a `redacted` flag so callers log the raw error server-side. Pluggable `redactedMessage` and `encodeData` hooks.
+- **`invariant` / `unreachable`** — assertion helpers that throw an internal-coded `VelaError` (rich in server logs, redacted on the wire).
+
+### Notes
+
+- Zero runtime dependencies; ESM; `sideEffects: false`; edge-runtime safe (no `node:*`, `Buffer`, or `process`).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kauan Guesser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# @velajs/errors
+
+Unified error layer for Vela: a single branded `VelaError` whose every field is an own-enumerable property (so it rides any wire codec, `structuredClone`, or Durable Object RPC prop-copy unchanged), composable error catalogs that default status/hint/docs from a code, and the one `toErrorBody` seam that redacts internal errors before they reach the wire. Zero runtime dependencies, edge-runtime safe.
+
+## Why
+
+Across HTTP, WebSocket, live queries, and queue reporting, Vela needs one answer to two questions: *"is this error safe to show a client?"* and *"what exact JSON goes on the wire?"* This package is that answer. Every transport edge funnels through `toErrorBody`, so the redaction invariant holds identically everywhere and the wire shape is pinned by a golden fixture.
+
+## The three redaction rules
+
+`toErrorBody(error, options?)` returns `{ body, status, redacted }`. Whether the original message/hint/details reach the client is decided by exactly these rules:
+
+| # | Input error | Result | `redacted` |
+| - | ----------- | ------ | ---------- |
+| 1 | Anything not a branded `VelaError` (plain `Error`, a foreign driver error that merely has `code`+`status`, `null`, …) | Generic title for the fallback status; original message dropped | `true` |
+| 2 | A branded `VelaError` whose code is the literal `internal`, **or** whose catalog entry has `internal: true` | `code` + `status` kept; message/hint/details dropped, replaced with the generic title for that status | `true` |
+| 3 | Any other branded `VelaError` — catalogued or open (unknown) code | `code`, `message`, and any `hint`/`docsUrl`/`details` echoed verbatim | `false` |
+
+Status alone never triggers redaction: an open code with `status: 500` still echoes (rule 3) — only the literal `internal` code or an `internal: true` catalog flag redacts (rule 2). `redacted: true` is the caller's signal to log the raw error server-side; `toErrorBody` itself never logs.
+
+The canonical wire shape (pinned by `wire-fixture.test.ts`) is:
+
+```json
+{ "error": { "code": "not_found", "message": "no such route", "hint": "Run `vela route list`." } }
+```
+
+and, redacted:
+
+```json
+{ "error": { "code": "internal", "message": "Internal Server Error" } }
+```
+
+## The brand contract
+
+`isVelaError` is a **branded structural** guard: it requires `error instanceof Error` plus `typeof code === 'string'`, `typeof status === 'number'`, and `type === 'VelaError'`. The `type` brand is an own-enumerable property, so it survives JSON round-trips, `structuredClone`, and DO↔worker RPC prop-copy — a wire-decoded twin (`Object.assign(new Error(msg), {...decoded})`) still passes. `instanceof VelaError` is deliberately **not** load-bearing (it breaks across realms and on decoded twins), so nothing in the redaction path uses it.
+
+The consequence for new transport edges: **construct real `VelaError`s, not shape-alikes.** A foreign error that merely carries `code` and `status` is intentionally rejected by the guard and redacted by rule 1 — that is the mechanism that stops a database driver's `internal driver detail: host=10.0.0.5` from riding the client-echo path.
+
+## Catalog composition
+
+A catalog maps codes to defaults (`status`, `title`, optional `hint`/`docsUrl`, and the `internal` redaction posture). `CORE_CATALOG` ships the standard HTTP-shaped codes. Compose your app's catalog onto it; duplicate codes throw at composition time.
+
+```ts
+import { CORE_CATALOG, composeCatalogs, defineErrorCatalog } from '@velajs/errors';
+
+const appCatalog = composeCatalogs(
+  CORE_CATALOG,
+  defineErrorCatalog({
+    order_expired: { status: 410, title: 'Order expired', hint: 'Create a new order.' },
+    db_corruption: { status: 500, title: 'Storage failure', internal: true },
+  }),
+);
+```
+
+> **Gotcha:** a custom catalog's `title` is **not** used as the thrown error's default message. Only core codes default their message to the catalog title; a throw for a custom-catalog code defaults its message to the code string unless you pass `message`. Pass `message` explicitly when you want human-readable text (and remember rule 2 will redact it anyway for `internal: true` entries). Use `catalog.error(code, options)` to inherit the entry's `status`/`hint`/`docsUrl`.
+
+## Usage
+
+```ts
+import { invariant, toErrorBody, VelaError } from '@velajs/errors';
+
+// Throw a catalogued error; status/hint default from the core catalog.
+throw new VelaError('not_found', { message: 'no such route', hint: 'Run `vela route list`.' });
+
+// Internal-coded errors are rich in logs, redacted on the wire.
+invariant(subscription !== undefined, 'subscription registry out of sync', { subId });
+
+// At every transport edge, funnel through the one seam:
+const { body, status, redacted } = toErrorBody(caughtError, { catalog: appCatalog });
+if (redacted) logger.error(caughtError); // safe details stay server-side
+return Response.json(body, { status });
+```
+
+`invariant(condition, message, data?)` narrows types (`asserts condition`) and, on failure, throws an `internal`-coded `VelaError` — always redacted by rule 2. `unreachable(value: never)` is its exhaustiveness-check companion.
+
+## API
+
+- `VelaError`, `VelaErrorOptions` — the one error and its constructor options.
+- `isVelaError`, `VelaErrorLike` — the branded structural guard and its type.
+- `toErrorBody`, `WireErrorObject`, `ErrorBodyResult`, `ToErrorBodyOptions` — the single wire-redaction seam.
+- `defineErrorCatalog`, `composeCatalogs`, `Catalog`, `ErrorCatalogEntry` — catalog authoring.
+- `CORE_CATALOG`, `CORE_ENTRIES`, `CoreErrorCode`, `STATUS_TO_CODE` — the core catalog and its lookups.
+- `invariant`, `unreachable` — internal-coded assertion helpers.

package/dist/catalog-data.d.ts

@@ -0,0 +1,76 @@
+export interface ErrorCatalogEntry {
+    status: number;
+    title: string;
+    hint?: string;
+    docsUrl?: string;
+    /** Redaction posture: true → message/hint/data are never echoed to clients. */
+    internal?: boolean;
+}
+export declare const CORE_ENTRIES: {
+    readonly bad_request: {
+        readonly status: 400;
+        readonly title: "Bad Request";
+    };
+    readonly unauthorized: {
+        readonly status: 401;
+        readonly title: "Unauthorized";
+    };
+    readonly forbidden: {
+        readonly status: 403;
+        readonly title: "Forbidden";
+    };
+    readonly not_found: {
+        readonly status: 404;
+        readonly title: "Not Found";
+    };
+    readonly method_not_allowed: {
+        readonly status: 405;
+        readonly title: "Method Not Allowed";
+    };
+    readonly conflict: {
+        readonly status: 409;
+        readonly title: "Conflict";
+    };
+    readonly gone: {
+        readonly status: 410;
+        readonly title: "Gone";
+    };
+    readonly payload_too_large: {
+        readonly status: 413;
+        readonly title: "Payload Too Large";
+    };
+    readonly unsupported_media_type: {
+        readonly status: 415;
+        readonly title: "Unsupported Media Type";
+    };
+    readonly unprocessable: {
+        readonly status: 422;
+        readonly title: "Unprocessable Entity";
+    };
+    readonly too_many_requests: {
+        readonly status: 429;
+        readonly title: "Too Many Requests";
+    };
+    readonly internal: {
+        readonly status: 500;
+        readonly title: "Internal Server Error";
+        readonly internal: true;
+    };
+    readonly not_implemented: {
+        readonly status: 501;
+        readonly title: "Not Implemented";
+    };
+    readonly bad_gateway: {
+        readonly status: 502;
+        readonly title: "Bad Gateway";
+    };
+    readonly service_unavailable: {
+        readonly status: 503;
+        readonly title: "Service Unavailable";
+    };
+    readonly gateway_timeout: {
+        readonly status: 504;
+        readonly title: "Gateway Timeout";
+    };
+};
+export type CoreErrorCode = keyof typeof CORE_ENTRIES;

package/dist/catalog-data.js

@@ -0,0 +1,67 @@
+export const CORE_ENTRIES = {
+    bad_request: {
+        status: 400,
+        title: 'Bad Request'
+    },
+    unauthorized: {
+        status: 401,
+        title: 'Unauthorized'
+    },
+    forbidden: {
+        status: 403,
+        title: 'Forbidden'
+    },
+    not_found: {
+        status: 404,
+        title: 'Not Found'
+    },
+    method_not_allowed: {
+        status: 405,
+        title: 'Method Not Allowed'
+    },
+    conflict: {
+        status: 409,
+        title: 'Conflict'
+    },
+    gone: {
+        status: 410,
+        title: 'Gone'
+    },
+    payload_too_large: {
+        status: 413,
+        title: 'Payload Too Large'
+    },
+    unsupported_media_type: {
+        status: 415,
+        title: 'Unsupported Media Type'
+    },
+    unprocessable: {
+        status: 422,
+        title: 'Unprocessable Entity'
+    },
+    too_many_requests: {
+        status: 429,
+        title: 'Too Many Requests'
+    },
+    internal: {
+        status: 500,
+        title: 'Internal Server Error',
+        internal: true
+    },
+    not_implemented: {
+        status: 501,
+        title: 'Not Implemented'
+    },
+    bad_gateway: {
+        status: 502,
+        title: 'Bad Gateway'
+    },
+    service_unavailable: {
+        status: 503,
+        title: 'Service Unavailable'
+    },
+    gateway_timeout: {
+        status: 504,
+        title: 'Gateway Timeout'
+    }
+};

package/dist/catalog.d.ts

@@ -0,0 +1,15 @@
+import { type CoreErrorCode, type ErrorCatalogEntry } from './catalog-data';
+import { VelaError, type VelaErrorOptions } from './error';
+export type { CoreErrorCode, ErrorCatalogEntry } from './catalog-data';
+export { CORE_ENTRIES } from './catalog-data';
+export interface Catalog<C extends string = string> {
+    readonly entries: Readonly<Record<C, ErrorCatalogEntry>>;
+    /** Typed thrower bound to this catalog's defaults. */
+    error(code: C | (string & {}), options?: VelaErrorOptions): VelaError;
+    has(code: string): boolean;
+    get(code: string): ErrorCatalogEntry | undefined;
+}
+export declare const defineErrorCatalog: <const T extends Record<string, ErrorCatalogEntry>>(entries: T) => Catalog<Extract<keyof T, string>>;
+export declare const composeCatalogs: (...catalogs: Array<Catalog<string>>) => Catalog<string>;
+export declare const CORE_CATALOG: Catalog<CoreErrorCode>;
+export declare const STATUS_TO_CODE: Readonly<Record<number, CoreErrorCode>>;

package/dist/catalog.js

@@ -0,0 +1,37 @@
+import { CORE_ENTRIES } from "./catalog-data.js";
+import { VelaError } from "./error.js";
+export { CORE_ENTRIES } from "./catalog-data.js";
+const makeCatalog = (entries)=>({
+        entries,
+        error (code, options = {}) {
+            const entry = entries[code];
+            return new VelaError(code, {
+                ...options,
+                status: options.status ?? entry?.status ?? 500,
+                hint: options.hint ?? entry?.hint,
+                docsUrl: options.docsUrl ?? entry?.docsUrl
+            });
+        },
+        has: (code)=>Object.hasOwn(entries, code),
+        get: (code)=>Object.hasOwn(entries, code) ? entries[code] : undefined
+    });
+export const defineErrorCatalog = (entries)=>makeCatalog(entries);
+export const composeCatalogs = (...catalogs)=>{
+    const merged = {};
+    for (const catalog of catalogs){
+        for (const [code, entry] of Object.entries(catalog.entries)){
+            if (Object.hasOwn(merged, code)) {
+                throw new VelaError('internal', {
+                    message: `duplicate error code '${code}' while composing catalogs`
+                });
+            }
+            merged[code] = entry;
+        }
+    }
+    return makeCatalog(merged);
+};
+export const CORE_CATALOG = makeCatalog(CORE_ENTRIES);
+export const STATUS_TO_CODE = Object.fromEntries(Object.entries(CORE_ENTRIES).map(([code, e])=>[
+        e.status,
+        code
+    ]));

package/dist/error.d.ts

@@ -0,0 +1,27 @@
+import { type CoreErrorCode } from './catalog-data';
+export interface VelaErrorOptions {
+    message?: string;
+    status?: number;
+    hint?: string;
+    docsUrl?: string;
+    data?: unknown;
+    cause?: unknown;
+}
+/**
+ * The one Vela error. Every field is an OWN ENUMERABLE property so the error
+ * rides any wire codec / structuredClone / DO-RPC prop-copy with no special
+ * serialization path. `type` is the brand `isVelaError` checks — it must
+ * survive serialization, which own+enumerable guarantees.
+ */
+export declare class VelaError extends Error {
+    readonly type = "VelaError";
+    readonly code: string;
+    readonly status: number;
+    readonly hint?: string;
+    readonly docsUrl?: string;
+    readonly data?: unknown;
+    constructor(code: CoreErrorCode, options?: VelaErrorOptions);
+    constructor(code: string, options: VelaErrorOptions & {
+        status: number;
+    });
+}

package/dist/error.js

@@ -0,0 +1,27 @@
+import { CORE_ENTRIES } from "./catalog-data.js";
+/**
+ * The one Vela error. Every field is an OWN ENUMERABLE property so the error
+ * rides any wire codec / structuredClone / DO-RPC prop-copy with no special
+ * serialization path. `type` is the brand `isVelaError` checks — it must
+ * survive serialization, which own+enumerable guarantees.
+ */ export class VelaError extends Error {
+    type = 'VelaError';
+    code;
+    status;
+    hint;
+    docsUrl;
+    data;
+    constructor(code, options = {}){
+        const entry = CORE_ENTRIES[code];
+        super(options.message ?? entry?.title ?? code, options.cause !== undefined ? {
+            cause: options.cause
+        } : undefined);
+        this.name = 'VelaError';
+        this.code = code;
+        this.status = options.status ?? entry?.status ?? 500;
+        if (options.hint ?? entry?.hint) this.hint = options.hint ?? entry?.hint;
+        if (options.docsUrl ?? entry?.docsUrl) this.docsUrl = options.docsUrl ?? entry?.docsUrl;
+        if (options.data !== undefined) this.data = options.data;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}

package/dist/guard.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Structural, realm-safe, BRANDED guard. `instanceof VelaError` is unreliable
+ * across DO↔worker RPC and for wire-decoded twins; a bare code+status shape
+ * check lets foreign driver errors ride the client-echo path. The brand
+ * (`type === 'VelaError'`, an own enumerable prop that survives serialization)
+ * closes both failure modes. Nothing load-bearing may use `instanceof`.
+ */
+export interface VelaErrorLike extends Error {
+    type: 'VelaError';
+    code: string;
+    status: number;
+    hint?: string;
+    docsUrl?: string;
+    data?: unknown;
+}
+export declare const isVelaError: (error: unknown) => error is VelaErrorLike;

package/dist/guard.js

@@ -0,0 +1,11 @@
+/**
+ * Structural, realm-safe, BRANDED guard. `instanceof VelaError` is unreliable
+ * across DO↔worker RPC and for wire-decoded twins; a bare code+status shape
+ * check lets foreign driver errors ride the client-echo path. The brand
+ * (`type === 'VelaError'`, an own enumerable prop that survives serialization)
+ * closes both failure modes. Nothing load-bearing may use `instanceof`.
+ */ export const isVelaError = (error)=>{
+    if (!(error instanceof Error)) return false;
+    const candidate = error;
+    return typeof candidate.code === 'string' && typeof candidate.status === 'number' && candidate.type === 'VelaError';
+};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { VelaError } from './error';
+export type { VelaErrorOptions } from './error';
+export { CORE_ENTRIES } from './catalog-data';
+export type { CoreErrorCode, ErrorCatalogEntry } from './catalog-data';
+export { CORE_CATALOG, STATUS_TO_CODE, composeCatalogs, defineErrorCatalog } from './catalog';
+export type { Catalog } from './catalog';
+export { isVelaError } from './guard';
+export type { VelaErrorLike } from './guard';
+export { toErrorBody } from './to-error-body';
+export type { ErrorBodyResult, ToErrorBodyOptions, WireErrorObject } from './to-error-body';
+export { invariant, unreachable } from './invariant';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { VelaError } from "./error.js";
+export { CORE_ENTRIES } from "./catalog-data.js";
+export { CORE_CATALOG, STATUS_TO_CODE, composeCatalogs, defineErrorCatalog } from "./catalog.js";
+export { isVelaError } from "./guard.js";
+export { toErrorBody } from "./to-error-body.js";
+export { invariant, unreachable } from "./invariant.js";

package/dist/invariant.d.ts

@@ -0,0 +1,3 @@
+/** Throws an internal-coded VelaError — rich in server logs, redacted on the wire. */
+export declare function invariant(condition: unknown, message: string, data?: unknown): asserts condition;
+export declare function unreachable(value: never, message?: string): never;

package/dist/invariant.js

@@ -0,0 +1,17 @@
+import { VelaError } from "./error.js";
+/** Throws an internal-coded VelaError — rich in server logs, redacted on the wire. */ export function invariant(condition, message, data) {
+    if (!condition) {
+        throw new VelaError('internal', {
+            message: `Invariant violation: ${message}`,
+            data
+        });
+    }
+}
+export function unreachable(value, message = 'unreachable code reached') {
+    throw new VelaError('internal', {
+        message,
+        data: {
+            value
+        }
+    });
+}

package/dist/to-error-body.d.ts

@@ -0,0 +1,34 @@
+import { type Catalog } from './catalog';
+export interface WireErrorObject {
+    code: string;
+    message: string;
+    hint?: string;
+    docsUrl?: string;
+    details?: unknown;
+}
+export interface ErrorBodyResult {
+    body: {
+        error: WireErrorObject;
+    };
+    status: number;
+    redacted: boolean;
+}
+export interface ToErrorBodyOptions {
+    /** Composed catalog; defaults to the core catalog. */
+    catalog?: Catalog<string>;
+    /** Status used for unbranded errors. Default 500. */
+    fallbackStatus?: number;
+    redactedMessage?: (status: number) => string;
+    /** Injectable wire codec for `data` → `details` (bigint/bytes etc.). */
+    encodeData?: (data: unknown) => unknown;
+    /** Default true. */
+    includeHint?: boolean;
+}
+/**
+ * THE single wire-redaction seam. Every transport edge (HTTP, WS, live, queue
+ * reporting) builds its client-bound error content here, so the invariant
+ * "unbranded or internal-coded errors never echo their message" holds
+ * identically everywhere. `redacted: true` is the caller's signal to log the
+ * raw error server-side — this function never logs (zero-dep purity).
+ */
+export declare const toErrorBody: (error: unknown, options?: ToErrorBodyOptions) => ErrorBodyResult;

package/dist/to-error-body.js

@@ -0,0 +1,50 @@
+import { CORE_CATALOG, STATUS_TO_CODE } from "./catalog.js";
+import { isVelaError } from "./guard.js";
+const defaultRedactedMessage = (status, catalog)=>{
+    const code = STATUS_TO_CODE[status];
+    return code && catalog.get(code)?.title || 'Internal Server Error';
+};
+/**
+ * THE single wire-redaction seam. Every transport edge (HTTP, WS, live, queue
+ * reporting) builds its client-bound error content here, so the invariant
+ * "unbranded or internal-coded errors never echo their message" holds
+ * identically everywhere. `redacted: true` is the caller's signal to log the
+ * raw error server-side — this function never logs (zero-dep purity).
+ */ export const toErrorBody = (error, options = {})=>{
+    const catalog = options.catalog ?? CORE_CATALOG;
+    const message = options.redactedMessage ?? ((s)=>defaultRedactedMessage(s, catalog));
+    const redact = (status, code)=>({
+            body: {
+                error: {
+                    code,
+                    message: message(status)
+                }
+            },
+            status,
+            redacted: true
+        });
+    if (!isVelaError(error)) {
+        const status = options.fallbackStatus ?? 500;
+        return redact(status, STATUS_TO_CODE[status] ?? 'internal');
+    }
+    const entry = catalog.get(error.code);
+    if (error.code === 'internal' || entry?.internal === true) {
+        return redact(error.status, error.code);
+    }
+    const wire = {
+        code: error.code,
+        message: error.message
+    };
+    const hint = error.hint ?? entry?.hint;
+    if (options.includeHint !== false && hint !== undefined) wire.hint = hint;
+    const docsUrl = error.docsUrl ?? entry?.docsUrl;
+    if (docsUrl !== undefined) wire.docsUrl = docsUrl;
+    if (error.data !== undefined) wire.details = options.encodeData ? options.encodeData(error.data) : error.data;
+    return {
+        body: {
+            error: wire
+        },
+        status: error.status,
+        redacted: false
+    };
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@velajs/errors",
+  "version": "1.0.0",
+  "description": "Unified error layer for Vela: branded VelaError, composable error catalogs, and the single toErrorBody wire-redaction seam",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "vela",
+    "errors",
+    "error-catalog",
+    "redaction",
+    "framework"
+  ],
+  "author": "ksh",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/velajs/errors.git"
+  },
+  "homepage": "https://github.com/velajs/errors#readme",
+  "bugs": {
+    "url": "https://github.com/velajs/errors/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@swc/cli": "^0.8.1",
+    "@swc/core": "^1.15.43",
+    "typescript": "^6.0.3",
+    "unplugin-swc": "^1.5.9",
+    "vitest": "^4.1.9"
+  },
+  "scripts": {
+    "build": "rm -rf dist && swc src -d dist --strip-leading-paths && tsc --emitDeclarationOnly",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit -p tsconfig.test.json"
+  }
+}