@zudojs/errors 0.1.0 → 1.0.0

package/dist/domain/scheduler/schedulerError.schedule.d.ts

@@ -1,7 +1,7 @@
 /**
  * Schedule-related error classes — schedule lifecycle, cron parsing.
  */
-import { SchedulerError } from "./schedulerError.base.js";
+import { SchedulerError, type SchedulerErrorOptions } from "./schedulerError.base.js";
 /** Error thrown when a schedule is not found. */
 export declare class ScheduleNotFoundError extends SchedulerError {
     constructor(scheduleId: string);
@@ -14,12 +14,22 @@ export declare class ScheduleAlreadyExistsError extends SchedulerError {
 export declare class InvalidScheduleError extends SchedulerError {
     constructor(message: string, scheduleId?: string);
 }
-/** Error thrown when a cron expression cannot be parsed. */
+/**
+ * Error thrown when a cron expression cannot be parsed.
+ *
+ * The expression is untrusted input: it is stripped of control characters
+ * and truncated before being embedded in the message or metadata.
+ */
 export declare class CronParseError extends SchedulerError {
-    constructor(expression: string, reason: string);
+    constructor(expression: string, reason: string, options?: SchedulerErrorOptions);
 }
-/** Error thrown when a duration string is invalid. */
+/**
+ * Error thrown when a duration string is invalid.
+ *
+ * The duration is untrusted input: it is stripped of control characters
+ * and truncated before being embedded in the message or metadata.
+ */
 export declare class InvalidDurationError extends SchedulerError {
-    constructor(duration: string);
+    constructor(duration: string, options?: SchedulerErrorOptions);
 }
 //# sourceMappingURL=schedulerError.schedule.d.ts.map

package/dist/domain/scheduler/schedulerError.schedule.js

@@ -2,7 +2,8 @@
  * Schedule-related error classes — schedule lifecycle, cron parsing.
  */
 import { ErrorCode } from "../../base/types/errorCode.type.js";
-import { SchedulerError } from "./schedulerError.base.js";
+import { MAX_METADATA_FRAGMENT_LENGTH, sanitizeFragment, } from "../shared/domainError.helpers.js";
+import { SchedulerError, } from "./schedulerError.base.js";
 /** Error thrown when a schedule is not found. */
 export class ScheduleNotFoundError extends SchedulerError {
     constructor(scheduleId) {
@@ -12,7 +13,6 @@ export class ScheduleNotFoundError extends SchedulerError {
             statusCode: 404,
             expose: true,
         });
-        this.name = "ScheduleNotFoundError";
     }
 }
 /** Error thrown when a schedule already exists. */
@@ -24,7 +24,6 @@ export class ScheduleAlreadyExistsError extends SchedulerError {
             statusCode: 409,
             expose: true,
         });
-        this.name = "ScheduleAlreadyExistsError";
     }
 }
 /** Error thrown when a schedule is invalid. */
@@ -36,31 +35,50 @@ export class InvalidScheduleError extends SchedulerError {
             statusCode: 400,
             expose: true,
         });
-        this.name = "InvalidScheduleError";
     }
 }
-/** Error thrown when a cron expression cannot be parsed. */
+/**
+ * Error thrown when a cron expression cannot be parsed.
+ *
+ * The expression is untrusted input: it is stripped of control characters
+ * and truncated before being embedded in the message or metadata.
+ */
 export class CronParseError extends SchedulerError {
-    constructor(expression, reason) {
-        super(`Invalid cron expression "${expression}": ${reason}.`, {
+    constructor(expression, reason, options = {}) {
+        const safeExpression = sanitizeFragment(expression);
+        const safeReason = sanitizeFragment(reason);
+        super(`Invalid cron expression "${safeExpression}": ${safeReason}.`, {
+            ...options,
             code: ErrorCode.CRON_PARSE_ERROR,
-            metadata: { expression, reason },
+            metadata: {
+                ...options.metadata,
+                expression: sanitizeFragment(expression, MAX_METADATA_FRAGMENT_LENGTH),
+                reason: safeReason,
+            },
             statusCode: 400,
             expose: true,
         });
-        this.name = "CronParseError";
     }
 }
-/** Error thrown when a duration string is invalid. */
+/**
+ * Error thrown when a duration string is invalid.
+ *
+ * The duration is untrusted input: it is stripped of control characters
+ * and truncated before being embedded in the message or metadata.
+ */
 export class InvalidDurationError extends SchedulerError {
-    constructor(duration) {
-        super(`Invalid duration "${duration}".`, {
+    constructor(duration, options = {}) {
+        const safeDuration = sanitizeFragment(duration);
+        super(`Invalid duration "${safeDuration}".`, {
+            ...options,
             code: ErrorCode.INVALID_DURATION,
-            metadata: { duration },
+            metadata: {
+                ...options.metadata,
+                duration: sanitizeFragment(duration, MAX_METADATA_FRAGMENT_LENGTH),
+            },
             statusCode: 400,
             expose: true,
         });
-        this.name = "InvalidDurationError";
     }
 }
 //# sourceMappingURL=schedulerError.schedule.js.map

package/dist/domain/schema/index.d.ts

@@ -3,5 +3,6 @@
  *
  * Schema error types for the Zudojs schema system.
  */
-export { SchemaError, SchemaTypeError, SchemaLiteralError, SchemaEnumError, SchemaStringError, SchemaNumberError, SchemaRequiredError, SchemaUnionError, SchemaUnknownKeyError, } from "./schema.error.js";
+export { SchemaError, SchemaTypeError, SchemaLiteralError, SchemaEnumError, SchemaStringError, SchemaNumberError, SchemaRequiredError, SchemaUnionError, SchemaUnknownKeyError, createSchemaError, isSchemaError, } from "./schema.error.js";
+export type { SchemaErrorOptions } from "./schema.error.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/domain/schema/index.js

@@ -3,5 +3,5 @@
  *
  * Schema error types for the Zudojs schema system.
  */
-export { SchemaError, SchemaTypeError, SchemaLiteralError, SchemaEnumError, SchemaStringError, SchemaNumberError, SchemaRequiredError, SchemaUnionError, SchemaUnknownKeyError, } from "./schema.error.js";
+export { SchemaError, SchemaTypeError, SchemaLiteralError, SchemaEnumError, SchemaStringError, SchemaNumberError, SchemaRequiredError, SchemaUnionError, SchemaUnknownKeyError, createSchemaError, isSchemaError, } from "./schema.error.js";
 //# sourceMappingURL=index.js.map

package/dist/domain/schema/schemaError.base.d.ts

@@ -2,20 +2,46 @@
  * Schema error base class and options.
  */
 import { BaseError } from "../../base/core/baseError.core.js";
-import { ErrorCode } from "../../base/types/errorCode.type.js";
+import type { BaseErrorOptions } from "../../base/types/baseError.type.js";
+import { ErrorCategory } from "../../base/types/errorCategory.type.js";
+import { ErrorSeverity } from "../../base/types/errorSeverity.type.js";
 /** Options for constructing a SchemaError. */
-export interface SchemaErrorOptions {
-    readonly code?: ErrorCode;
+export interface SchemaErrorOptions extends Omit<BaseErrorOptions, "category"> {
+    readonly category?: ErrorCategory;
     readonly issues?: readonly unknown[];
-    readonly cause?: unknown;
 }
 /**
  * Base error for all schema validation failures.
  *
- * Carries structured issues that describe exactly what failed.
+ * Carries structured issues that describe exactly what failed. The issues
+ * array is a frozen copy of the caller's input. When the error is exposable
+ * (the default), `toJSON()` replaces submitted values inside issues
+ * (`value`, `received`, `input`, `actual`) with a type/size description so
+ * that secrets submitted by a client are never echoed back or logged.
  */
 export declare class SchemaError extends BaseError {
     readonly issues: readonly unknown[];
     constructor(message: string, options?: SchemaErrorOptions);
+    /** Returns whether any issues were recorded. */
+    hasIssues(): boolean;
+    /** Returns a serialized representation including (redacted) issues. */
+    toJSON(): {
+        name: string;
+        message: string;
+        code: string;
+        category: ErrorCategory;
+        severity: ErrorSeverity;
+        statusCode: number;
+        expose: boolean;
+        isOperational: boolean;
+        metadata: Readonly<import("../../index.js").ErrorMetadata>;
+        stack?: string;
+        cause?: import("../../base/types/baseError.type.js").SerializedBaseError | unknown;
+        issues: readonly unknown[];
+    };
 }
+/** Creates a schema error. */
+export declare function createSchemaError(message: string, options?: SchemaErrorOptions): SchemaError;
+/** Determines whether an unknown value is a SchemaError. */
+export declare function isSchemaError(value: unknown): value is SchemaError;
 //# sourceMappingURL=schemaError.base.d.ts.map

package/dist/domain/schema/schemaError.base.js

@@ -4,22 +4,50 @@
 import { BaseError } from "../../base/core/baseError.core.js";
 import { ErrorCode } from "../../base/types/errorCode.type.js";
 import { ErrorCategory } from "../../base/types/errorCategory.type.js";
+import { ErrorSeverity } from "../../base/types/errorSeverity.type.js";
+import { redactIssueValues, toJsonSafeIssues, } from "../shared/domainError.helpers.js";
 /**
  * Base error for all schema validation failures.
  *
- * Carries structured issues that describe exactly what failed.
+ * Carries structured issues that describe exactly what failed. The issues
+ * array is a frozen copy of the caller's input. When the error is exposable
+ * (the default), `toJSON()` replaces submitted values inside issues
+ * (`value`, `received`, `input`, `actual`) with a type/size description so
+ * that secrets submitted by a client are never echoed back or logged.
  */
 export class SchemaError extends BaseError {
     issues;
     constructor(message, options = {}) {
         super(message, {
+            ...options,
             code: options.code ?? ErrorCode.SCHEMA_VALIDATION,
-            category: ErrorCategory.VALIDATION,
-            statusCode: 400,
-            expose: true,
-            cause: options.cause,
+            category: options.category ?? ErrorCategory.VALIDATION,
+            severity: options.severity ?? ErrorSeverity.WARNING,
+            statusCode: options.statusCode ?? 400,
+            expose: options.expose ?? true,
+            isOperational: options.isOperational ?? true,
         });
-        this.issues = options.issues ?? [];
+        this.issues = Object.freeze([...(options.issues ?? [])]);
     }
+    /** Returns whether any issues were recorded. */
+    hasIssues() {
+        return this.issues.length > 0;
+    }
+    /** Returns a serialized representation including (redacted) issues. */
+    toJSON() {
+        const safeIssues = toJsonSafeIssues(this.issues);
+        return {
+            ...super.toJSON(),
+            issues: this.expose ? redactIssueValues(safeIssues) : safeIssues,
+        };
+    }
+}
+/** Creates a schema error. */
+export function createSchemaError(message, options = {}) {
+    return new SchemaError(message, options);
+}
+/** Determines whether an unknown value is a SchemaError. */
+export function isSchemaError(value) {
+    return value instanceof SchemaError;
 }
 //# sourceMappingURL=schemaError.base.js.map

package/dist/domain/schema/schemaError.types.js

@@ -2,13 +2,19 @@
  * Specific schema error classes.
  */
 import { ErrorCode } from "../../base/types/errorCode.type.js";
+import { describeValue, safeStringify, sanitizeFragment, } from "../shared/domainError.helpers.js";
 import { SchemaError } from "./schemaError.base.js";
+/*
+ * Messages built here never embed the received (submitted) value; they use a
+ * type/size description instead. Expected values come from the schema
+ * definition and are serialized with a non-throwing stringifier.
+ */
 /**
  * Error thrown when a value does not match the expected type.
  */
 export class SchemaTypeError extends SchemaError {
     constructor(expected, received, path = []) {
-        super(`Expected ${expected}, received ${received}`, {
+        super(`Expected ${sanitizeFragment(expected)}, received ${sanitizeFragment(received)}`, {
             code: ErrorCode.SCHEMA_INVALID_TYPE,
             issues: [{ code: "invalid_type", path, expected, received }],
         });
@@ -19,7 +25,7 @@ export class SchemaTypeError extends SchemaError {
  */
 export class SchemaLiteralError extends SchemaError {
     constructor(expected, received, path = []) {
-        super(`Expected literal ${JSON.stringify(expected)}, received ${JSON.stringify(received)}`, {
+        super(`Expected literal ${sanitizeFragment(safeStringify(expected))}, received ${describeValue(received)}`, {
             code: ErrorCode.SCHEMA_INVALID_LITERAL,
             issues: [{ code: "invalid_literal", path, expected, received }],
         });
@@ -30,7 +36,7 @@ export class SchemaLiteralError extends SchemaError {
  */
 export class SchemaEnumError extends SchemaError {
     constructor(expected, received, path = []) {
-        super(`Expected one of ${expected.map((v) => JSON.stringify(v)).join(", ")}`, {
+        super(`Expected one of ${sanitizeFragment(expected.map((v) => safeStringify(v)).join(", "))}, received ${describeValue(received)}`, {
             code: ErrorCode.SCHEMA_INVALID_ENUM,
             issues: [{ code: "invalid_enum", path, expected, received }],
         });
@@ -85,9 +91,10 @@ export class SchemaUnionError extends SchemaError {
  */
 export class SchemaUnknownKeyError extends SchemaError {
     constructor(key, path = []) {
-        super(`Unknown key: ${key}`, {
+        const safeKey = sanitizeFragment(key);
+        super(`Unknown key: ${safeKey}`, {
             code: ErrorCode.SCHEMA_UNKNOWN_KEY,
-            issues: [{ code: "unknown_keys", path, key }],
+            issues: [{ code: "unknown_keys", path, key: safeKey }],
         });
     }
 }

package/dist/domain/serialization/serializationError.base.d.ts

@@ -4,6 +4,7 @@
 import { BaseError } from "../../base/core/baseError.core.js";
 import type { BaseErrorOptions } from "../../base/types/baseError.type.js";
 import { ErrorCategory } from "../../base/types/errorCategory.type.js";
+import { ErrorCode } from "../../base/types/errorCode.type.js";
 import { ErrorSeverity } from "../../base/types/errorSeverity.type.js";
 /** Options for creating a serialization error. */
 export interface SerializationErrorOptions extends Omit<BaseErrorOptions, "category"> {
@@ -19,6 +20,12 @@ export interface SerializationErrorOptions extends Omit<BaseErrorOptions, "categ
 /** Base error for all serialization subsystem failures. */
 export declare class SerializationError extends BaseError {
     readonly format?: string;
+    readonly depth?: number;
+    readonly maxDepth?: number;
+    readonly size?: number;
+    readonly maxSize?: number;
+    readonly transformerType?: string;
+    readonly serializerName?: string;
     constructor(message: string, options?: SerializationErrorOptions);
     toJSON(): {
         name: string;
@@ -32,7 +39,6 @@ export declare class SerializationError extends BaseError {
         metadata: Readonly<import("../../index.js").ErrorMetadata>;
         stack?: string;
         cause?: import("../../base/types/baseError.type.js").SerializedBaseError | unknown;
-        format?: string | undefined;
     };
 }
 /** Creates a serialization error. */
@@ -42,6 +48,6 @@ export declare function isSerializationError(value: unknown): value is Serializa
 /** Converts an unknown thrown value into a SerializationError. */
 export declare function toSerializationError(error: unknown, options?: {
     message?: string;
-    code?: string;
+    code?: ErrorCode | string;
 }): SerializationError;
 //# sourceMappingURL=serializationError.base.d.ts.map

package/dist/domain/serialization/serializationError.base.js

@@ -5,10 +5,33 @@ import { BaseError } from "../../base/core/baseError.core.js";
 import { ErrorCategory } from "../../base/types/errorCategory.type.js";
 import { ErrorCode } from "../../base/types/errorCode.type.js";
 import { ErrorSeverity } from "../../base/types/errorSeverity.type.js";
+import { safeErrorMessage } from "../shared/domainError.helpers.js";
+/** Diagnostic fields carried by serialization errors. */
+const DIAGNOSTIC_KEYS = [
+    "format",
+    "depth",
+    "maxDepth",
+    "size",
+    "maxSize",
+    "transformerType",
+    "serializerName",
+];
 /** Base error for all serialization subsystem failures. */
 export class SerializationError extends BaseError {
     format;
+    depth;
+    maxDepth;
+    size;
+    maxSize;
+    transformerType;
+    serializerName;
     constructor(message, options = {}) {
+        const diagnostics = {};
+        for (const key of DIAGNOSTIC_KEYS) {
+            const value = options[key];
+            if (value !== undefined)
+                diagnostics[key] = value;
+        }
         super(message, {
             ...options,
             code: options.code ?? ErrorCode.SERIALIZATION,
@@ -17,13 +40,26 @@ export class SerializationError extends BaseError {
             statusCode: options.statusCode ?? 500,
             expose: options.expose ?? false,
             isOperational: options.isOperational ?? true,
+            metadata: { ...options.metadata, ...diagnostics },
         });
         this.format = options.format;
+        this.depth = options.depth;
+        this.maxDepth = options.maxDepth;
+        this.size = options.size;
+        this.maxSize = options.maxSize;
+        this.transformerType = options.transformerType;
+        this.serializerName = options.serializerName;
     }
     toJSON() {
+        const diagnostics = {};
+        for (const key of DIAGNOSTIC_KEYS) {
+            const value = this[key];
+            if (value !== undefined)
+                diagnostics[key] = value;
+        }
         return {
             ...super.toJSON(),
-            ...(this.format !== undefined ? { format: this.format } : {}),
+            ...diagnostics,
         };
     }
 }
@@ -40,13 +76,7 @@ export function toSerializationError(error, options = {}) {
     if (error instanceof SerializationError) {
         return error;
     }
-    if (error instanceof Error) {
-        return new SerializationError(options.message ?? error.message, {
-            code: options.code,
-            cause: error,
-        });
-    }
-    return new SerializationError(options.message ?? String(error), {
+    return new SerializationError(options.message ?? safeErrorMessage(error), {
         code: options.code,
         cause: error,
     });

package/dist/domain/serialization/serializationError.types.d.ts

@@ -9,7 +9,12 @@ export declare class SerializeError extends SerializationError {
         cause?: unknown;
     });
 }
-/** Error thrown when deserialization fails. */
+/**
+ * Error thrown when deserialization fails.
+ *
+ * Malformed serialized input is a client/input problem, so this is a 400
+ * that may be exposed.
+ */
 export declare class DeserializeError extends SerializationError {
     constructor(message: string, options?: {
         format?: string;
@@ -25,20 +30,34 @@ export declare class SerializerNotFoundError extends SerializationError {
     readonly serializerName: string;
     constructor(name: string);
 }
-/** Error thrown when a circular reference is detected during serialization. */
+/**
+ * Error thrown when a circular reference is detected during serialization.
+ *
+ * Circular data is a server-side data bug, so this is an internal (500) error.
+ */
 export declare class CircularReferenceError extends SerializationError {
     readonly circularPath: string;
     constructor(path?: string);
 }
-/** Error thrown when maximum serialization depth is exceeded. */
+/**
+ * Error thrown when maximum serialization depth is exceeded.
+ *
+ * Over-deep data is a server-side data bug, so this is an internal (500) error.
+ */
 export declare class SerializationDepthError extends SerializationError {
     readonly depth: number;
+    readonly maxDepth: number;
+    /** @deprecated Use `maxDepth`. */
     readonly maxDepthValue: number;
     constructor(depth: number, maxDepth: number);
 }
 /** Error thrown when a serialized payload exceeds the size limit. */
 export declare class SerializationPayloadTooLargeError extends SerializationError {
+    readonly size: number;
+    readonly maxSize: number;
+    /** @deprecated Use `size`. */
     readonly payloadSize: number;
+    /** @deprecated Use `maxSize`. */
     readonly maxSizeValue: number;
     constructor(size: number, maxSize: number);
 }

package/dist/domain/serialization/serializationError.types.js

@@ -13,13 +13,20 @@ export class SerializeError extends SerializationError {
         });
     }
 }
-/** Error thrown when deserialization fails. */
+/**
+ * Error thrown when deserialization fails.
+ *
+ * Malformed serialized input is a client/input problem, so this is a 400
+ * that may be exposed.
+ */
 export class DeserializeError extends SerializationError {
     constructor(message, options = {}) {
         super(message, {
             code: ErrorCode.DESERIALIZATION_FAILED,
             format: options.format,
             cause: options.cause,
+            statusCode: 400,
+            expose: true,
         });
     }
 }
@@ -47,37 +54,53 @@ export class SerializerNotFoundError extends SerializationError {
         this.serializerName = name;
     }
 }
-/** Error thrown when a circular reference is detected during serialization. */
+/**
+ * Error thrown when a circular reference is detected during serialization.
+ *
+ * Circular data is a server-side data bug, so this is an internal (500) error.
+ */
 export class CircularReferenceError extends SerializationError {
     circularPath;
     constructor(path = "root") {
         super(`Circular reference detected at "${path}"`, {
             code: ErrorCode.CIRCULAR_REFERENCE,
-            statusCode: 400,
+            statusCode: 500,
             expose: false,
+            metadata: { circularPath: path },
         });
         this.circularPath = path;
     }
 }
-/** Error thrown when maximum serialization depth is exceeded. */
+/**
+ * Error thrown when maximum serialization depth is exceeded.
+ *
+ * Over-deep data is a server-side data bug, so this is an internal (500) error.
+ */
 export class SerializationDepthError extends SerializationError {
     depth;
+    maxDepth;
+    /** @deprecated Use `maxDepth`. */
     maxDepthValue;
     constructor(depth, maxDepth) {
         super(`Maximum serialization depth exceeded: ${depth} > ${maxDepth}`, {
             code: ErrorCode.MAX_DEPTH_EXCEEDED,
             depth,
             maxDepth,
-            statusCode: 400,
+            statusCode: 500,
             expose: false,
         });
         this.depth = depth;
+        this.maxDepth = maxDepth;
         this.maxDepthValue = maxDepth;
     }
 }
 /** Error thrown when a serialized payload exceeds the size limit. */
 export class SerializationPayloadTooLargeError extends SerializationError {
+    size;
+    maxSize;
+    /** @deprecated Use `size`. */
     payloadSize;
+    /** @deprecated Use `maxSize`. */
     maxSizeValue;
     constructor(size, maxSize) {
         super(`Serialized payload too large: ${size} bytes (max: ${maxSize})`, {
@@ -87,6 +110,8 @@ export class SerializationPayloadTooLargeError extends SerializationError {
             statusCode: 413,
             expose: false,
         });
+        this.size = size;
+        this.maxSize = maxSize;
         this.payloadSize = size;
         this.maxSizeValue = maxSize;
     }

package/dist/domain/shared/domainError.helpers.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Shared helpers for domain error classes.
+ *
+ * These utilities keep untrusted input out of error messages, make
+ * normalizers robust against exotic thrown values, and validate the
+ * numeric arguments that domain errors record.
+ */
+import type { ErrorMetadata } from "../../base/core/errorMetadata.type.js";
+/** Default maximum length for untrusted strings embedded in messages. */
+export declare const MAX_MESSAGE_FRAGMENT_LENGTH = 200;
+/** Default maximum length for untrusted strings stored in metadata. */
+export declare const MAX_METADATA_FRAGMENT_LENGTH = 1024;
+/**
+ * Removes control characters (including newlines and ANSI escapes) and
+ * truncates the string so it can be safely embedded in a message or log line.
+ */
+export declare function sanitizeFragment(value: unknown, maxLength?: number): string;
+/**
+ * Serializes any value to a string without throwing.
+ *
+ * Handles BigInt, circular structures, symbols, and objects whose
+ * `toString` throws. Never returns more than `maxLength` characters.
+ */
+export declare function safeStringify(value: unknown, maxLength?: number): string;
+/**
+ * Describes a value by type and size without revealing its contents.
+ *
+ * Use this instead of embedding submitted values into exposed messages.
+ */
+export declare function describeValue(value: unknown): string;
+/**
+ * Produces a message for an unknown thrown value without throwing.
+ */
+export declare function safeErrorMessage(error: unknown): string;
+/**
+ * Asserts that a numeric argument is finite and non-negative.
+ */
+export declare function assertFiniteNonNegative(name: string, value: number): number;
+/**
+ * Normalizes a retry-after value in seconds to a finite, non-negative integer
+ * (rounded up), as required by the HTTP `Retry-After` header.
+ */
+export declare function normalizeRetryAfterSeconds(value: number, name?: string): number;
+/**
+ * Merges caller-provided metadata with class-specific fields, letting the
+ * class-specific fields win.
+ */
+export declare function mergeMetadata(callerMetadata: ErrorMetadata | undefined, own: ErrorMetadata): ErrorMetadata;
+/**
+ * Removes submitted values from a list of issue objects so they can be
+ * exposed to clients. Values are replaced by a type/size description under
+ * `<key>Type`.
+ */
+export declare function redactIssueValues<T>(issues: readonly T[]): readonly T[];
+/**
+ * Converts issue objects into JSON-safe structures (no BigInt, no cycles)
+ * so that `JSON.stringify` on the error never throws.
+ */
+export declare function toJsonSafeIssues<T>(issues: readonly T[]): readonly T[];
+//# sourceMappingURL=domainError.helpers.d.ts.map