@zudojs/errors 0.1.1 → 1.0.1

package/dist/domain/rpc/rpcError.protocol.js

@@ -14,7 +14,6 @@ export class RPCValidationError extends RPCError {
             statusCode: 422,
             expose: true,
         });
-        this.name = "RPCValidationError";
         this.issues = Object.freeze([...issues]);
     }
 }
@@ -27,7 +26,6 @@ export class RPCAuthenticationError extends RPCError {
             statusCode: 401,
             expose: true,
         });
-        this.name = "RPCAuthenticationError";
     }
 }
 /** Error thrown when RPC authorization fails. */
@@ -39,7 +37,6 @@ export class RPCForbiddenError extends RPCError {
             statusCode: 403,
             expose: true,
         });
-        this.name = "RPCForbiddenError";
     }
 }
 /** Error thrown when an unexpected internal RPC error occurs. */
@@ -52,7 +49,6 @@ export class RPCInternalError extends RPCError {
             expose: false,
             isOperational: false,
         });
-        this.name = "RPCInternalError";
     }
 }
 /** Error thrown when RPC serialization fails. */
@@ -64,7 +60,6 @@ export class RPCSerializationError extends RPCError {
             statusCode: 500,
             expose: false,
         });
-        this.name = "RPCSerializationError";
     }
 }
 /** Error thrown when RPC deserialization fails. */
@@ -76,7 +71,6 @@ export class RPCDeserializationError extends RPCError {
             statusCode: 400,
             expose: true,
         });
-        this.name = "RPCDeserializationError";
     }
 }
 /** Error thrown when a duplicate RPC procedure is registered. */
@@ -88,7 +82,6 @@ export class RPCDuplicateProcedureError extends RPCError {
             statusCode: 409,
             expose: true,
         });
-        this.name = "RPCDuplicateProcedureError";
     }
 }
 //# sourceMappingURL=rpcError.protocol.js.map

package/dist/domain/rpc/rpcError.transport.d.ts

@@ -19,8 +19,17 @@ export declare class RPCTransportError extends RPCError {
 export declare class RPCUnavailableError extends RPCError {
     constructor(message?: string, procedureName?: string);
 }
-/** Error thrown when an RPC rate limit is exceeded. */
+/**
+ * Error thrown when an RPC rate limit is exceeded.
+ *
+ * `retryAfter` is expressed in seconds (as the HTTP `Retry-After` header);
+ * fractional values are rounded up and the value is only recorded in
+ * metadata (as `retryAfterSeconds`) when provided.
+ */
 export declare class RPCRateLimitedError extends RPCError {
+    /** Seconds to wait before retrying, if known. */
+    readonly retryAfterSeconds?: number;
+    /** @deprecated Use `retryAfterSeconds`. */
     readonly retryAfter?: number;
     constructor(message?: string, retryAfter?: number, procedureName?: string);
 }

package/dist/domain/rpc/rpcError.transport.js

@@ -2,11 +2,13 @@
  * RPC transport error classes — timeout, cancelled, availability.
  */
 import { ErrorCode } from "../../base/types/errorCode.type.js";
+import { assertFiniteNonNegative, normalizeRetryAfterSeconds, } from "../shared/domainError.helpers.js";
 import { RPCError } from "./rpcError.base.js";
 /** Error thrown when an RPC operation times out. */
 export class RPCTimeoutError extends RPCError {
     timeout;
     constructor(timeout, procedureName) {
+        assertFiniteNonNegative("timeout", timeout);
         super(`RPC operation timed out after ${timeout}ms.`, {
             code: ErrorCode.RPC_TIMEOUT,
             procedureName,
@@ -14,7 +16,6 @@ export class RPCTimeoutError extends RPCError {
             statusCode: 504,
             expose: false,
         });
-        this.name = "RPCTimeoutError";
         this.timeout = timeout;
     }
 }
@@ -27,7 +28,6 @@ export class RPCCancelledError extends RPCError {
             statusCode: 499,
             expose: false,
         });
-        this.name = "RPCCancelledError";
     }
 }
 /** Error thrown when an RPC transport error occurs. */
@@ -39,7 +39,6 @@ export class RPCTransportError extends RPCError {
             statusCode: 502,
             expose: false,
         });
-        this.name = "RPCTransportError";
     }
 }
 /** Error thrown when an RPC service is unavailable. */
@@ -51,27 +50,39 @@ export class RPCUnavailableError extends RPCError {
             statusCode: 503,
             expose: true,
         });
-        this.name = "RPCUnavailableError";
     }
 }
-/** Error thrown when an RPC rate limit is exceeded. */
+/**
+ * Error thrown when an RPC rate limit is exceeded.
+ *
+ * `retryAfter` is expressed in seconds (as the HTTP `Retry-After` header);
+ * fractional values are rounded up and the value is only recorded in
+ * metadata (as `retryAfterSeconds`) when provided.
+ */
 export class RPCRateLimitedError extends RPCError {
+    /** Seconds to wait before retrying, if known. */
+    retryAfterSeconds;
+    /** @deprecated Use `retryAfterSeconds`. */
     retryAfter;
     constructor(message = "RPC rate limit exceeded.", retryAfter, procedureName) {
+        const retryAfterSeconds = retryAfter !== undefined
+            ? normalizeRetryAfterSeconds(retryAfter, "retryAfter")
+            : undefined;
         super(message, {
             code: ErrorCode.RPC_RATE_LIMITED,
             procedureName,
-            metadata: { retryAfter },
+            metadata: retryAfterSeconds !== undefined ? { retryAfterSeconds } : {},
             statusCode: 429,
             expose: true,
         });
-        this.name = "RPCRateLimitedError";
-        this.retryAfter = retryAfter;
+        this.retryAfterSeconds = retryAfterSeconds;
+        this.retryAfter = retryAfterSeconds;
     }
 }
 /** Error thrown when an RPC deadline is exceeded. */
 export class RPCDeadlineExceededError extends RPCError {
     constructor(deadline, procedureName) {
+        assertFiniteNonNegative("deadline", deadline);
         super(`RPC deadline exceeded at ${deadline}.`, {
             code: ErrorCode.RPC_DEADLINE_EXCEEDED,
             procedureName,
@@ -79,7 +90,6 @@ export class RPCDeadlineExceededError extends RPCError {
             statusCode: 504,
             expose: false,
         });
-        this.name = "RPCDeadlineExceededError";
     }
 }
 //# sourceMappingURL=rpcError.transport.js.map

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

@@ -36,15 +36,29 @@ export declare class SchedulerError extends BaseError {
 export declare function createSchedulerError(message: string, options?: SchedulerErrorOptions): SchedulerError;
 /** Determines whether an unknown value is a SchedulerError. */
 export declare function isSchedulerError(value: unknown): value is SchedulerError;
-/** Error thrown when the scheduler has not been started. */
+/**
+ * Error thrown when the scheduler has not been started.
+ *
+ * Scheduler state is a server-side concern: reported as 503 (temporarily
+ * unavailable), not exposed, non-operational.
+ */
 export declare class SchedulerNotStartedError extends SchedulerError {
     constructor();
 }
-/** Error thrown when the scheduler is already started. */
+/**
+ * Error thrown when the scheduler is already started.
+ *
+ * Scheduler state is a server-side concern: reported as internal.
+ */
 export declare class SchedulerAlreadyStartedError extends SchedulerError {
     constructor();
 }
-/** Error thrown when the scheduler is stopped. */
+/**
+ * Error thrown when the scheduler is stopped.
+ *
+ * Scheduler state is a server-side concern: reported as 503 (temporarily
+ * unavailable), not exposed, non-operational.
+ */
 export declare class SchedulerStoppedError extends SchedulerError {
     constructor();
 }

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

@@ -38,37 +38,51 @@ export function createSchedulerError(message, options = {}) {
 export function isSchedulerError(value) {
     return value instanceof SchedulerError;
 }
-/** Error thrown when the scheduler has not been started. */
+/**
+ * Error thrown when the scheduler has not been started.
+ *
+ * Scheduler state is a server-side concern: reported as 503 (temporarily
+ * unavailable), not exposed, non-operational.
+ */
 export class SchedulerNotStartedError extends SchedulerError {
     constructor() {
         super("Scheduler has not been started.", {
             code: ErrorCode.SCHEDULER_NOT_STARTED,
-            statusCode: 400,
-            expose: true,
+            statusCode: 503,
+            expose: false,
+            isOperational: false,
         });
-        this.name = "SchedulerNotStartedError";
     }
 }
-/** Error thrown when the scheduler is already started. */
+/**
+ * Error thrown when the scheduler is already started.
+ *
+ * Scheduler state is a server-side concern: reported as internal.
+ */
 export class SchedulerAlreadyStartedError extends SchedulerError {
     constructor() {
         super("Scheduler is already started.", {
             code: ErrorCode.SCHEDULER_ALREADY_STARTED,
-            statusCode: 400,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
-        this.name = "SchedulerAlreadyStartedError";
     }
 }
-/** Error thrown when the scheduler is stopped. */
+/**
+ * Error thrown when the scheduler is stopped.
+ *
+ * Scheduler state is a server-side concern: reported as 503 (temporarily
+ * unavailable), not exposed, non-operational.
+ */
 export class SchedulerStoppedError extends SchedulerError {
     constructor() {
         super("Scheduler is stopped.", {
             code: ErrorCode.SCHEDULER_STOPPED,
-            statusCode: 400,
-            expose: true,
+            statusCode: 503,
+            expose: false,
+            isOperational: false,
         });
-        this.name = "SchedulerStoppedError";
     }
 }
 /** Error thrown when a job is not found. */
@@ -80,7 +94,6 @@ export class SchedulerJobNotFoundError extends SchedulerError {
             statusCode: 404,
             expose: true,
         });
-        this.name = "SchedulerJobNotFoundError";
     }
 }
 /** Error thrown when a job already exists. */
@@ -92,7 +105,6 @@ export class SchedulerJobAlreadyExistsError extends SchedulerError {
             statusCode: 409,
             expose: true,
         });
-        this.name = "SchedulerJobAlreadyExistsError";
     }
 }
 /** Error thrown when a job definition is invalid. */
@@ -104,7 +116,6 @@ export class InvalidJobError extends SchedulerError {
             statusCode: 400,
             expose: true,
         });
-        this.name = "InvalidJobError";
     }
 }
 //# sourceMappingURL=schedulerError.base.js.map

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

@@ -1,25 +1,26 @@
 /**
  * Scheduler execution error classes — job execution, timeout, cancellation, store, lock.
  */
-import { SchedulerError } from "./schedulerError.base.js";
+import { SchedulerError, type SchedulerErrorOptions } from "./schedulerError.base.js";
 /** Error thrown when a job execution fails. */
 export declare class SchedulerJobExecutionError extends SchedulerError {
-    constructor(message: string, jobId?: string, scheduleId?: string);
+    constructor(message: string, jobId?: string, scheduleId?: string, options?: SchedulerErrorOptions);
 }
 /** Error thrown when a job times out. */
 export declare class SchedulerJobTimeoutError extends SchedulerError {
-    constructor(timeout: number, jobId?: string);
+    readonly timeout: number;
+    constructor(timeout: number, jobId?: string, options?: SchedulerErrorOptions);
 }
 /** Error thrown when a job is cancelled. */
 export declare class SchedulerJobCancelledError extends SchedulerError {
-    constructor(message?: string, jobId?: string);
+    constructor(message?: string, jobId?: string, options?: SchedulerErrorOptions);
 }
 /** Error thrown when the scheduler store encounters an error. */
 export declare class SchedulerStoreError extends SchedulerError {
-    constructor(message: string, scheduleId?: string);
+    constructor(message: string, scheduleId?: string, options?: SchedulerErrorOptions);
 }
 /** Error thrown when the scheduler lock encounters an error. */
 export declare class SchedulerLockError extends SchedulerError {
-    constructor(message: string, scheduleId?: string);
+    constructor(message: string, scheduleId?: string, options?: SchedulerErrorOptions);
 }
 //# sourceMappingURL=schedulerError.execution.d.ts.map

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

@@ -2,67 +2,71 @@
  * Scheduler execution error classes — job execution, timeout, cancellation, store, lock.
  */
 import { ErrorCode } from "../../base/types/errorCode.type.js";
-import { SchedulerError } from "./schedulerError.base.js";
+import { assertFiniteNonNegative } from "../shared/domainError.helpers.js";
+import { SchedulerError, } from "./schedulerError.base.js";
 /** Error thrown when a job execution fails. */
 export class SchedulerJobExecutionError extends SchedulerError {
-    constructor(message, jobId, scheduleId) {
+    constructor(message, jobId, scheduleId, options = {}) {
         super(message, {
+            ...options,
             code: ErrorCode.SCHEDULER_JOB_EXECUTION_ERROR,
-            jobId,
-            scheduleId,
+            jobId: jobId ?? options.jobId,
+            scheduleId: scheduleId ?? options.scheduleId,
             statusCode: 500,
             expose: false,
         });
-        this.name = "SchedulerJobExecutionError";
     }
 }
 /** Error thrown when a job times out. */
 export class SchedulerJobTimeoutError extends SchedulerError {
-    constructor(timeout, jobId) {
+    timeout;
+    constructor(timeout, jobId, options = {}) {
+        assertFiniteNonNegative("timeout", timeout);
         super(`Job timed out after ${timeout}ms.`, {
+            ...options,
             code: ErrorCode.SCHEDULER_JOB_TIMEOUT,
-            jobId,
-            metadata: { timeout },
+            jobId: jobId ?? options.jobId,
+            metadata: { ...options.metadata, timeout },
             statusCode: 504,
             expose: false,
         });
-        this.name = "SchedulerJobTimeoutError";
+        this.timeout = timeout;
     }
 }
 /** Error thrown when a job is cancelled. */
 export class SchedulerJobCancelledError extends SchedulerError {
-    constructor(message = "Job was cancelled.", jobId) {
+    constructor(message = "Job was cancelled.", jobId, options = {}) {
         super(message, {
+            ...options,
             code: ErrorCode.SCHEDULER_JOB_CANCELLED,
-            jobId,
+            jobId: jobId ?? options.jobId,
             statusCode: 499,
             expose: false,
         });
-        this.name = "SchedulerJobCancelledError";
     }
 }
 /** Error thrown when the scheduler store encounters an error. */
 export class SchedulerStoreError extends SchedulerError {
-    constructor(message, scheduleId) {
+    constructor(message, scheduleId, options = {}) {
         super(message, {
+            ...options,
             code: ErrorCode.SCHEDULER_STORE_ERROR,
-            scheduleId,
+            scheduleId: scheduleId ?? options.scheduleId,
             statusCode: 500,
             expose: false,
         });
-        this.name = "SchedulerStoreError";
     }
 }
 /** Error thrown when the scheduler lock encounters an error. */
 export class SchedulerLockError extends SchedulerError {
-    constructor(message, scheduleId) {
+    constructor(message, scheduleId, options = {}) {
         super(message, {
+            ...options,
             code: ErrorCode.SCHEDULER_LOCK_ERROR,
-            scheduleId,
+            scheduleId: scheduleId ?? options.scheduleId,
             statusCode: 409,
             expose: false,
         });
-        this.name = "SchedulerLockError";
     }
 }
 //# sourceMappingURL=schedulerError.execution.js.map

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