@honua/react 0.0.20-alpha.0 → 0.1.1-beta.0

package/core/error-envelope.js

@@ -0,0 +1,357 @@
+/**
+ * Shared, serialization-safe error contract for public Honua SDK failures.
+ *
+ * Error instances retain their original `message`, `cause`, and legacy detail
+ * fields for local debugging. Use {@link serializeHonuaError} at telemetry or
+ * process boundaries: it emits only registered classifications and sanitized
+ * context, never messages, stacks, response bodies, or cause payloads.
+ */
+import { HONUA_ERROR_RUNTIME_CLASSIFICATIONS } from "./error-classifications.js";
+export const HONUA_ERROR_KIND = "honua.sdk.error.v1";
+/** Base class for every migrated public SDK error. */
+export class HonuaSdkError extends Error {
+    kind = HONUA_ERROR_KIND;
+    domain;
+    /** Globally unique registry code. Legacy subclasses may retain a separate `.code`. */
+    sdkCode;
+    category;
+    retryable;
+    operationId;
+    requestId;
+    context;
+    constructor(code, message, options = {}) {
+        const [domain, category, retryable] = errorCodeClassification(code);
+        super(message, "cause" in options ? { cause: options.cause } : undefined);
+        this.name = "HonuaSdkError";
+        this.domain = domain;
+        this.sdkCode = code;
+        this.category = category;
+        this.retryable = retryable;
+        this.operationId = sanitizeIdentifier(options.operationId);
+        this.requestId = sanitizeIdentifier(options.requestId);
+        this.context = sanitizeHonuaErrorContext(options.context);
+    }
+    /** Safe JSON projection. Raw messages, stacks, details, bodies, and causes are intentionally omitted. */
+    toJSON() {
+        return serializeHonuaError(this);
+    }
+}
+/** Cross-realm type guard backed by the public tag and registered code. */
+export function isHonuaSdkError(error) {
+    try {
+        if (!isRecord(error) || Array.isArray(error))
+            return false;
+        const kind = ownDataProperty(error, "kind");
+        const sdkCode = ownDataProperty(error, "sdkCode");
+        if (kind !== HONUA_ERROR_KIND || typeof sdkCode !== "string" || !isHonuaErrorCode(sdkCode))
+            return false;
+        const [domain, category, retryable] = HONUA_ERROR_RUNTIME_CLASSIFICATIONS[sdkCode];
+        const context = ownDataProperty(error, "context");
+        const name = ownDataProperty(error, "name");
+        return (ownDataProperty(error, "domain") === domain &&
+            ownDataProperty(error, "retryable") === retryable &&
+            ownDataProperty(error, "category") === category &&
+            typeof name === "string" &&
+            isRecord(context) &&
+            !Array.isArray(context));
+    }
+    catch {
+        return false;
+    }
+}
+/** Serialize a tagged SDK error without crossing its redaction boundary. */
+export function serializeHonuaError(error) {
+    const sdkCode = ownDataProperty(error, "sdkCode");
+    if (typeof sdkCode !== "string" || !isHonuaErrorCode(sdkCode)) {
+        throw new TypeError("Cannot serialize an SDK error with an unregistered code");
+    }
+    const [domain, category, retryable] = HONUA_ERROR_RUNTIME_CLASSIFICATIONS[sdkCode];
+    const cause = serializeCause(ownDataProperty(error, "cause"));
+    const operationId = sanitizeIdentifier(asOptionalString(ownDataProperty(error, "operationId")));
+    const requestId = sanitizeIdentifier(asOptionalString(ownDataProperty(error, "requestId")));
+    const context = ownDataProperty(error, "context");
+    return {
+        kind: HONUA_ERROR_KIND,
+        name: sanitizeErrorName(ownDataProperty(error, "name")),
+        domain,
+        code: sdkCode,
+        category,
+        retryable,
+        ...(operationId ? { operationId } : {}),
+        ...(requestId ? { requestId } : {}),
+        context: isRecord(context) && !Array.isArray(context) ? sanitizeHonuaErrorContext(context) : emptyContext(),
+        ...(cause ? { cause } : {}),
+    };
+}
+/** Redact structured context before it is stored on an SDK error. */
+export function sanitizeHonuaErrorContext(context) {
+    if (!context)
+        return emptyContext();
+    try {
+        const seen = new WeakSet();
+        const sanitized = sanitizeRecord(context, seen, 0);
+        return Object.freeze(sanitized);
+    }
+    catch {
+        return frozenRecord("value", "[UNSERIALIZABLE]");
+    }
+}
+/** Merge context inputs without invoking enumerable accessors or honoring prototype-manipulation keys. */
+export function mergeHonuaErrorContext(...contexts) {
+    const merged = Object.create(null);
+    let unsafeKeyCount = 0;
+    for (const context of contexts) {
+        if (!context)
+            continue;
+        for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(context))) {
+            if (!descriptor.enumerable)
+                continue;
+            if (UNSAFE_PROPERTY_KEY.test(key)) {
+                unsafeKeyCount += 1;
+                continue;
+            }
+            merged[key] = "value" in descriptor ? descriptor.value : "[ACCESSOR]";
+        }
+    }
+    if (unsafeKeyCount > 0)
+        merged.__redacted_keys__ = unsafeKeyCount;
+    return merged;
+}
+export function isHonuaErrorCode(code) {
+    return Object.hasOwn(HONUA_ERROR_RUNTIME_CLASSIFICATIONS, code);
+}
+/** @internal True only for a valid tagged retryable network or timeout classification. */
+export function isRetryableNetworkOrTimeoutHonuaError(error) {
+    try {
+        if (!isHonuaSdkError(error))
+            return false;
+        const sdkCode = ownDataProperty(error, "sdkCode");
+        if (typeof sdkCode !== "string" || !isHonuaErrorCode(sdkCode))
+            return false;
+        const [, category, retryable] = HONUA_ERROR_RUNTIME_CLASSIFICATIONS[sdkCode];
+        return retryable && (category === "network" || category === "timeout");
+    }
+    catch {
+        return false;
+    }
+}
+function errorCodeClassification(code) {
+    if (!isHonuaErrorCode(code))
+        throw new TypeError(`Unregistered Honua SDK error code: ${code}`);
+    return HONUA_ERROR_RUNTIME_CLASSIFICATIONS[code];
+}
+const REDACTED = "[REDACTED]";
+const TRUNCATED = "[TRUNCATED]";
+const MAX_DEPTH = 6;
+const MAX_PROPERTIES = 100;
+const MAX_ARRAY_ITEMS = 100;
+const MAX_STRING_LENGTH = 2_048;
+const SENSITIVE_KEY = /(?:authorization|proxy-authorization|cookie|set-cookie|credential|password|passwd|secret|token|api[-_]?key|access[-_]?key|access[-_]?id|signature|cursor|resume[-_]?token|where|filter|query|sql|cql|body|payload|form|parameters?)/i;
+const STORAGE_LOCATOR_KEY = /^(?:local[-_]?storage|storage|cache(?:[-_]?file)?|file|filesystem)[-_]?(?:path|directory|url|uri|location)$/i;
+const URL_KEY = /(?:url|uri|href|endpoint|location)$/i;
+function sanitizeRecord(value, seen, depth) {
+    if (depth >= MAX_DEPTH)
+        return frozenRecord("value", TRUNCATED);
+    if (seen.has(value))
+        return frozenRecord("value", "[CIRCULAR]");
+    seen.add(value);
+    const output = Object.create(null);
+    const descriptors = Object.entries(Object.getOwnPropertyDescriptors(value))
+        .filter(([, descriptor]) => descriptor.enumerable)
+        .slice(0, MAX_PROPERTIES);
+    let unsafeKeyCount = 0;
+    for (const [key, descriptor] of descriptors) {
+        if (UNSAFE_PROPERTY_KEY.test(key)) {
+            unsafeKeyCount += 1;
+            continue;
+        }
+        const item = "value" in descriptor ? descriptor.value : "[ACCESSOR]";
+        output[key] =
+            SENSITIVE_KEY.test(key) || STORAGE_LOCATOR_KEY.test(key) ? REDACTED : sanitizeValue(item, key, seen, depth + 1);
+    }
+    if (unsafeKeyCount > 0)
+        output.__redacted_keys__ = unsafeKeyCount;
+    if (Reflect.ownKeys(value).length > descriptors.length)
+        output.__truncated__ = TRUNCATED;
+    seen.delete(value);
+    return Object.freeze(output);
+}
+function sanitizeValue(value, key, seen, depth) {
+    if (value === null || typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : String(value);
+    if (typeof value === "string")
+        return sanitizeString(value, URL_KEY.test(key));
+    if (typeof value === "bigint")
+        return value.toString();
+    if (typeof value === "undefined")
+        return "[UNDEFINED]";
+    if (typeof value === "function" || typeof value === "symbol")
+        return "[UNSERIALIZABLE]";
+    if (value instanceof Error)
+        return frozenRecord("name", errorNameWithoutGetters(value));
+    if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer)
+        return "[BINARY]";
+    if (value instanceof Date) {
+        const time = Date.prototype.getTime.call(value);
+        return Number.isNaN(time) ? "[INVALID_DATE]" : Date.prototype.toISOString.call(value);
+    }
+    if (Array.isArray(value)) {
+        if (depth >= MAX_DEPTH)
+            return TRUNCATED;
+        if (seen.has(value))
+            return "[CIRCULAR]";
+        seen.add(value);
+        const result = value
+            .slice(0, MAX_ARRAY_ITEMS)
+            .map((item) => sanitizeValue(item, key, seen, depth + 1));
+        if (value.length > result.length)
+            result.push(TRUNCATED);
+        seen.delete(value);
+        return Object.freeze(result);
+    }
+    if (isRecord(value))
+        return sanitizeRecord(value, seen, depth);
+    return "[UNSERIALIZABLE]";
+}
+function sanitizeString(value, urlExpected) {
+    const bounded = value.length > MAX_STRING_LENGTH ? `${value.slice(0, MAX_STRING_LENGTH)}${TRUNCATED}` : value;
+    if (urlExpected || /^https?:\/\//i.test(bounded)) {
+        try {
+            const url = new URL(bounded);
+            url.username = "";
+            url.password = "";
+            for (const key of [...url.searchParams.keys()]) {
+                if (isSensitiveQueryParameter(key))
+                    url.searchParams.set(key, REDACTED);
+            }
+            url.hash = "";
+            return url.toString();
+        }
+        catch {
+            if (urlExpected)
+                return REDACTED;
+        }
+    }
+    return bounded
+        .replace(/\bBearer\s+[^\s,;]+/gi, `Bearer ${REDACTED}`)
+        .replace(/\b(access_token|refresh_token|api[-_]?key|password|passwd|secret|token|cursor|resume[-_]?token)\s*[:=]\s*([^\s,;&]+)/gi, (_match, name) => `${name}=${REDACTED}`);
+}
+function sanitizeIdentifier(value) {
+    if (value === undefined)
+        return undefined;
+    return /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/.test(value) ? value : REDACTED;
+}
+function asOptionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function serializeCause(cause) {
+    if (cause === undefined)
+        return undefined;
+    try {
+        if (isHonuaSdkError(cause)) {
+            const sdkCode = ownDataProperty(cause, "sdkCode");
+            if (typeof sdkCode !== "string" || !isHonuaErrorCode(sdkCode))
+                return { name: "Error" };
+            const [domain, category, retryable] = HONUA_ERROR_RUNTIME_CLASSIFICATIONS[sdkCode];
+            return {
+                name: sanitizeErrorName(ownDataProperty(cause, "name")),
+                domain,
+                code: sdkCode,
+                category,
+                retryable,
+            };
+        }
+        if (cause instanceof Error)
+            return { name: errorNameWithoutGetters(cause) };
+        return { name: typeof cause };
+    }
+    catch {
+        return { name: "Error" };
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object";
+}
+function ownDataProperty(value, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor && "value" in descriptor ? descriptor.value : undefined;
+}
+function sanitizeErrorName(value) {
+    return typeof value === "string" && SAFE_ERROR_NAMES.has(value) ? value : "Error";
+}
+function errorNameWithoutGetters(error) {
+    try {
+        const ownName = ownDataProperty(error, "name");
+        if (typeof ownName === "string")
+            return sanitizeErrorName(ownName);
+        const prototype = Object.getPrototypeOf(error);
+        return prototype ? sanitizeErrorName(ownDataProperty(prototype, "name")) : "Error";
+    }
+    catch {
+        return "Error";
+    }
+}
+function isSensitiveQueryParameter(key) {
+    const normalized = key.toLocaleLowerCase("en-US").replace(/[^a-z0-9]+/g, "");
+    return (normalized === "key" ||
+        /(?:accesstoken|refreshtoken|securitytoken|accesskeyid|accessid|credential|authorization|apikey|signature|password|passwd|secret|cursor|resumetoken|continuationtoken|filter|where|query|sql|cql|auth|sig)$/.test(normalized));
+}
+const UNSAFE_PROPERTY_KEY = /^(?:__proto__|prototype|constructor)$/;
+const SAFE_ERROR_NAMES = new Set([
+    "AbortError",
+    "AggregateError",
+    "ConnectError",
+    "DOMException",
+    "Error",
+    "EvalError",
+    "HonuaAbortError",
+    "HonuaAgentExecutionError",
+    "HonuaAgentSafetyError",
+    "HonuaAgentToolError",
+    "HonuaAuthError",
+    "HonuaAutomaticMapLibreIntegrationError",
+    "HonuaAutomaticMapLibreStrategyError",
+    "HonuaCapabilityNotSupportedError",
+    "HonuaDataToMapBridgeError",
+    "HonuaDiscoveryError",
+    "HonuaExplorationContextError",
+    "HonuaGeneratedAppError",
+    "HonuaGrpcError",
+    "HonuaHttpError",
+    "HonuaJobFailedError",
+    "HonuaMapLibreRasterStrategyError",
+    "HonuaMapLibreSourceAdapterError",
+    "HonuaMapPackageError",
+    "HonuaNetworkError",
+    "HonuaOfflineRegionError",
+    "HonuaPluginRegistryError",
+    "HonuaQueryPlanExecutionError",
+    "HonuaQueryPlanningError",
+    "HonuaRealtimeResumeError",
+    "HonuaReplicaSyncError",
+    "HonuaRuntimeDiagnosticError",
+    "HonuaSdkError",
+    "HonuaTemporalPlaybackError",
+    "HonuaTimeoutError",
+    "HonuaWfsExceptionError",
+    "HonuaWmsCapabilitiesParseError",
+    "HonuaWmtsCapabilitiesParseError",
+    "NetworkError",
+    "QueryTileServerResponseError",
+    "RangeError",
+    "ReferenceError",
+    "SyntaxError",
+    "TimeoutError",
+    "TypeError",
+    "URIError",
+]);
+function emptyContext() {
+    return Object.freeze(Object.create(null));
+}
+function frozenRecord(key, value) {
+    const record = Object.create(null);
+    record[key] = value;
+    return Object.freeze(record);
+}

package/core/errors.d.ts

@@ -1,8 +1,9 @@
 /**
- * Honua SDK error hierarchy. Every error thrown by `@honua/sdk-js` is an
- * instance of one of the classes in this file plus the runtime-type guard
- * `isHonuaError(error)`. See [`docs/errors.md`](../../docs/errors.md) for the
- * full reference table including recovery hints and the retry-policy mapping.
+ * Tagged hierarchy for the migrated Honua SDK error domains. The common
+ * `isHonuaError(error)` guard also recognizes migrated query, map, runtime,
+ * realtime, offline, and plugin subclasses. See
+ * [`docs/errors.md`](../../docs/errors.md) for exact coverage, residual domains,
+ * recovery hints, and the retryability classification.
  *
  * @example
  * ```ts
@@ -29,9 +30,26 @@
  *
  * @packageDocumentation
  */
-import { HonuaJobFailedError } from "./ogc-processes.js";
-import { HonuaWmsCapabilitiesParseError } from "./wms-capabilities.js";
-import { HonuaWmtsCapabilitiesParseError } from "./wmts-capabilities.js";
+import { type HonuaErrorMetadata, type HonuaErrorOptions, HonuaSdkError } from "./error-envelope.js";
+export type HonuaDiscoveryErrorCode = "ambiguous-protocol" | "ambiguous-source" | "invalid-endpoint" | "invalid-cache-identity" | "invalid-discovery-cache" | "invalid-capability" | "unsupported-protocol" | "protocol-mismatch";
+/** Discovery input, metadata, or cache identity is invalid or inconsistent. */
+export declare class HonuaDiscoveryError extends HonuaSdkError {
+    readonly code: HonuaDiscoveryErrorCode;
+    readonly detail?: Readonly<Record<string, unknown>> | undefined;
+    constructor(code: HonuaDiscoveryErrorCode, message: string, detail?: Readonly<Record<string, unknown>> | undefined, options?: HonuaErrorOptions);
+}
+/** Stable reason codes for geometry inputs that cannot be classified safely. */
+export type HonuaGeometryErrorCode = "unknown-geometry" | "malformed-geometry";
+/**
+ * Thrown when a geometry cannot be classified without guessing. The structured
+ * `code` and `detail` fields let callers distinguish an unsupported shape from
+ * a recognized-but-malformed Esri geometry without parsing the message.
+ */
+export declare class HonuaGeometryError extends HonuaSdkError {
+    readonly code: HonuaGeometryErrorCode;
+    readonly detail?: Readonly<Record<string, unknown>> | undefined;
+    constructor(code: HonuaGeometryErrorCode, message: string, detail?: Readonly<Record<string, unknown>> | undefined, options?: HonuaErrorOptions);
+}
 /**
  * Thrown when the server returns a non-2xx HTTP status. Branch on
  * `.statusCode` to decide recovery: refresh credentials on 401/403, respect
@@ -39,30 +57,30 @@ import { HonuaWmtsCapabilitiesParseError } from "./wmts-capabilities.js";
  *
  * @see [`docs/errors.md`](../../docs/errors.md)
  */
-export declare class HonuaHttpError extends Error {
+export declare class HonuaHttpError extends HonuaSdkError {
     readonly statusCode: number;
     readonly body: unknown;
-    constructor(statusCode: number, message: string, body: unknown);
+    constructor(statusCode: number, message: string, body: unknown, options?: HonuaErrorOptions);
 }
 /** Thrown when a request exceeds the configured timeout. */
-export declare class HonuaTimeoutError extends Error {
+export declare class HonuaTimeoutError extends HonuaSdkError {
     readonly timeoutMs: number;
-    constructor(timeoutMs: number);
+    constructor(timeoutMs: number, options?: HonuaErrorOptions);
 }
 /** Thrown when a network-level failure occurs (DNS, connection refused, etc.). */
-export declare class HonuaNetworkError extends Error {
+export declare class HonuaNetworkError extends HonuaSdkError {
     readonly cause: unknown;
-    constructor(message: string, cause: unknown);
+    constructor(message: string, cause: unknown, metadata?: HonuaErrorMetadata);
 }
 /** Thrown when a request is aborted via a caller-provided AbortSignal. */
-export declare class HonuaAbortError extends Error {
-    constructor(message?: string);
+export declare class HonuaAbortError extends HonuaSdkError {
+    constructor(message?: string, options?: HonuaErrorOptions);
 }
 /** Thrown when a gRPC-Web request fails, wrapping the underlying ConnectError. */
-export declare class HonuaGrpcError extends Error {
+export declare class HonuaGrpcError extends HonuaSdkError {
     readonly code: number;
     readonly details: unknown;
-    constructor(code: number, message: string, details?: unknown);
+    constructor(code: number, message: string, details?: unknown, options?: HonuaErrorOptions);
 }
 /**
  * Thrown when a `Source` is asked to perform an operation that the underlying
@@ -71,11 +89,41 @@ export declare class HonuaGrpcError extends Error {
  * decide whether to swap protocols, fall back to a degraded strategy, or
  * surface the limitation to the user.
  */
-export declare class HonuaCapabilityNotSupportedError extends Error {
+export declare class HonuaCapabilityNotSupportedError extends HonuaSdkError {
     readonly capability: string;
     readonly protocol: string;
     readonly sourceId: string | undefined;
-    constructor(capability: string, protocol: string, sourceId?: string);
+    constructor(capability: string, protocol: string, sourceId?: string, options?: HonuaErrorOptions);
+}
+/**
+ * Cause codes for {@link HonuaAuthError}. They classify *why* an auth flow
+ * could not produce a usable credential so callers can branch without parsing
+ * message strings:
+ *
+ * - `interaction_required` — no cached credential and no way to obtain one
+ *   silently (no refresh token, or the refresh token is gone). The app must
+ *   start an interactive sign-in (`oauth2(...).signIn()`).
+ * - `refresh_failed` — a silent refresh attempt failed for a transient reason
+ *   (network/5xx/timeout at the token endpoint). Retrying later may succeed.
+ * - `invalid_grant` — the authorization server rejected the grant
+ *   (`error: "invalid_grant"`): the refresh token or authorization code is
+ *   expired/revoked/invalid. The stored credential is cleared and interactive
+ *   sign-in is required.
+ */
+export type HonuaAuthErrorCode = "interaction_required" | "refresh_failed" | "invalid_grant";
+/**
+ * Thrown by the auth providers (`oauth2`, `clientCredentials`, …) when a
+ * credential cannot be produced. Branch on `.code` (see {@link HonuaAuthErrorCode})
+ * to decide whether to start interactive sign-in, retry the refresh later, or
+ * surface the failure to the user. The underlying transport/parse failure, when
+ * present, is preserved on `.cause`.
+ *
+ * @see [`docs/errors.md`](../../docs/errors.md)
+ */
+export declare class HonuaAuthError extends HonuaSdkError {
+    readonly code: HonuaAuthErrorCode;
+    readonly cause: unknown;
+    constructor(code: HonuaAuthErrorCode, message: string, options?: HonuaErrorOptions);
 }
 /**
  * Thrown when an `ExplorationContext` operation is invalid — for example,
@@ -83,9 +131,9 @@ export declare class HonuaCapabilityNotSupportedError extends Error {
  * an incompatible snapshot, or binding a view that requests a slice that is
  * not exposed by the current dataset.
  */
-export declare class HonuaExplorationContextError extends Error {
+export declare class HonuaExplorationContextError extends HonuaSdkError {
     readonly code: string;
-    constructor(code: string, message: string);
+    constructor(code: string, message: string, options?: HonuaErrorOptions);
 }
 /**
  * Thrown when a WFS server replies with an `ows:ExceptionReport`. Carries the
@@ -95,13 +143,13 @@ export declare class HonuaExplorationContextError extends Error {
  * `src/core/wfs-capabilities.ts`; raw access lives behind the `protocol("wfs")`
  * escape hatch.
  */
-export declare class HonuaWfsExceptionError extends Error {
+export declare class HonuaWfsExceptionError extends HonuaSdkError {
     readonly exceptionCode: string;
     readonly locator: string | undefined;
-    constructor(exceptionCode: string, message: string, locator?: string);
+    constructor(exceptionCode: string, message: string, locator?: string, options?: HonuaErrorOptions);
 }
-/** All Honua SDK error types that can be discriminated with `instanceof`. */
-export type HonuaError = HonuaHttpError | HonuaTimeoutError | HonuaNetworkError | HonuaAbortError | HonuaGrpcError | HonuaCapabilityNotSupportedError | HonuaExplorationContextError | HonuaWfsExceptionError | HonuaJobFailedError | HonuaWmsCapabilitiesParseError | HonuaWmtsCapabilitiesParseError;
+/** Any public SDK error participating in the tagged envelope. */
+export type HonuaError = HonuaSdkError;
 /** Type guard that narrows any value to one of the Honua SDK error types. */
 export declare function isHonuaError(error: unknown): error is HonuaError;
 //# sourceMappingURL=errors.d.ts.map

package/core/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/core/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,+BAA+B,EAAE,MAAM,wBAAwB,CAAC;AAEzE;;;;;;GAMG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC,SAAgB,UAAU,EAAE,MAAM,CAAC;IACnC,SAAgB,IAAI,EAAE,OAAO,CAAC;gBAEX,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;CAMtE;AAED,4DAA4D;AAC5D,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,SAAgB,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM;CAKrC;AAED,kFAAkF;AAClF,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,SAAyB,KAAK,EAAE,OAAO,CAAC;gBAErB,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;CAKnD;AAED,0EAA0E;AAC1E,qBAAa,eAAgB,SAAQ,KAAK;gBACrB,OAAO,SAAwB;CAInD;AAED,kFAAkF;AAClF,qBAAa,cAAe,SAAQ,KAAK;IACvC,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,OAAO,EAAE,OAAO,CAAC;gBAEd,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO;CAMpE;AAED;;;;;;GAMG;AACH,qBAAa,gCAAiC,SAAQ,KAAK;IACzD,SAAgB,UAAU,EAAE,MAAM,CAAC;IACnC,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;gBAE1B,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAW3E;AAED;;;;;GAKG;AACH,qBAAa,4BAA6B,SAAQ,KAAK;IACrD,SAAgB,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAKjD;AAED;;;;;;;GAOG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,SAAgB,aAAa,EAAE,MAAM,CAAC;IACtC,SAAgB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;gBAEzB,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;CAU5E;AAED,6EAA6E;AAC7E,MAAM,MAAM,UAAU,GAClB,cAAc,GACd,iBAAiB,GACjB,iBAAiB,GACjB,eAAe,GACf,cAAc,GACd,gCAAgC,GAChC,4BAA4B,GAC5B,sBAAsB,GACtB,mBAAmB,GACnB,8BAA8B,GAC9B,+BAA+B,CAAC;AAEpC,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAchE"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/core/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,aAAa,EAGd,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,uBAAuB,GAC/B,oBAAoB,GACpB,kBAAkB,GAClB,kBAAkB,GAClB,wBAAwB,GACxB,yBAAyB,GACzB,oBAAoB,GACpB,sBAAsB,GACtB,mBAAmB,CAAC;AAExB,+EAA+E;AAC/E,qBAAa,mBAAoB,SAAQ,aAAa;aAElC,IAAI,EAAE,uBAAuB;aAE7B,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAF1C,IAAI,EAAE,uBAAuB,EAC7C,OAAO,EAAE,MAAM,EACC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,YAAA,EAC1D,OAAO,GAAE,iBAAsB;CAQlC;AAED,gFAAgF;AAChF,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,GAAG,oBAAoB,CAAC;AAE/E;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,aAAa;aAEjC,IAAI,EAAE,sBAAsB;aAE5B,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAF1C,IAAI,EAAE,sBAAsB,EAC5C,OAAO,EAAE,MAAM,EACC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,YAAA,EAC1D,OAAO,GAAE,iBAAsB;CAQlC;AAED;;;;;;GAMG;AACH,qBAAa,cAAe,SAAQ,aAAa;IAC/C,SAAgB,UAAU,EAAE,MAAM,CAAC;IACnC,SAAgB,IAAI,EAAE,OAAO,CAAC;gBAEX,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,GAAE,iBAAsB;CAavG;AAED,4DAA4D;AAC5D,qBAAa,iBAAkB,SAAQ,aAAa;IAClD,SAAgB,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB;CAQtE;AAED,kFAAkF;AAClF,qBAAa,iBAAkB,SAAQ,aAAa;IAClD,SAAyB,KAAK,EAAE,OAAO,CAAC;gBAErB,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,GAAE,kBAAuB;CAKtF;AAED,0EAA0E;AAC1E,qBAAa,eAAgB,SAAQ,aAAa;gBAC7B,OAAO,SAAwB,EAAE,OAAO,GAAE,iBAAsB;CAIpF;AAED,kFAAkF;AAClF,qBAAa,cAAe,SAAQ,aAAa;aAI7B,IAAI,EAAE,MAAM;IAH9B,SAAgB,OAAO,EAAE,OAAO,CAAC;gBAGf,IAAI,EAAE,MAAM,EAC5B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,OAAO,EACjB,OAAO,GAAE,iBAAsB;CASlC;AAED;;;;;;GAMG;AACH,qBAAa,gCAAiC,SAAQ,aAAa;IACjE,SAAgB,UAAU,EAAE,MAAM,CAAC;IACnC,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;gBAE1B,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB;CAa5G;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,kBAAkB,GAAG,sBAAsB,GAAG,gBAAgB,GAAG,eAAe,CAAC;AAE7F;;;;;;;;GAQG;AACH,qBAAa,cAAe,SAAQ,aAAa;aAI7B,IAAI,EAAE,kBAAkB;IAH1C,SAAyB,KAAK,EAAE,OAAO,CAAC;gBAGtB,IAAI,EAAE,kBAAkB,EACxC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,iBAAsB;CAMlC;AAED;;;;;GAKG;AACH,qBAAa,4BAA6B,SAAQ,aAAa;aAE3C,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM,EAC5B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,iBAAsB;CAQlC;AAED;;;;;;;GAOG;AACH,qBAAa,sBAAuB,SAAQ,aAAa;IACvD,SAAgB,aAAa,EAAE,MAAM,CAAC;IACtC,SAAgB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;gBAEzB,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB;CAY7G;AAED,iEAAiE;AACjE,MAAM,MAAM,UAAU,GAAG,aAAa,CAAC;AAEvC,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE"}