@zudojs/errors 0.1.1 → 1.0.1

package/dist/domain/message/messageError.base.js

@@ -5,11 +5,13 @@ 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";
 /** Base error for all message subsystem failures. */
 export class MessageError extends BaseError {
     messageType;
     messageId;
     handlerId;
+    middlewareId;
     constructor(message, options = {}) {
         super(message, {
             ...options,
@@ -23,6 +25,7 @@ export class MessageError extends BaseError {
         this.messageType = options.messageType;
         this.messageId = options.messageId;
         this.handlerId = options.handlerId;
+        this.middlewareId = options.middlewareId;
     }
     toJSON() {
         return {
@@ -32,6 +35,9 @@ export class MessageError extends BaseError {
                 : {}),
             ...(this.messageId !== undefined ? { messageId: this.messageId } : {}),
             ...(this.handlerId !== undefined ? { handlerId: this.handlerId } : {}),
+            ...(this.middlewareId !== undefined
+                ? { middlewareId: this.middlewareId }
+                : {}),
         };
     }
 }
@@ -48,15 +54,7 @@ export function toMessageError(error, options = {}) {
     if (error instanceof MessageError) {
         return error;
     }
-    if (error instanceof Error) {
-        return new MessageError(options.message ?? error.message, {
-            code: options.code,
-            messageType: options.messageType,
-            messageId: options.messageId,
-            cause: error,
-        });
-    }
-    return new MessageError(options.message ?? String(error), {
+    return new MessageError(options.message ?? safeErrorMessage(error), {
         code: options.code,
         messageType: options.messageType,
         messageId: options.messageId,

package/dist/domain/message/messageError.handler.d.ts

@@ -13,17 +13,26 @@ export declare class MessageHandlerError extends MessageError {
 }
 /** Creates a message handler error from an unknown failure. */
 export declare function createMessageHandlerError(handlerId: string, messageType: string, messageId: string, cause: unknown): MessageHandlerError;
-/** Error thrown when a message handler cannot be found. */
+/**
+ * Error thrown when a message handler cannot be found.
+ *
+ * Handler registration is a server-side concern, so this is an internal
+ * (non-exposed, non-operational) failure.
+ */
 export declare class MessageHandlerNotFoundError extends MessageError {
     constructor(handlerId: string);
 }
-/** Error thrown when a message handler is already registered. */
+/**
+ * Error thrown when a message handler is already registered.
+ *
+ * Handler registration is a server-side concern, so this is an internal
+ * (non-exposed, non-operational) failure.
+ */
 export declare class DuplicateMessageHandlerError extends MessageError {
     constructor(handlerId: string);
 }
 /** Error thrown when message middleware fails. */
 export declare class MessageMiddlewareError extends MessageError {
-    readonly middlewareId?: string;
     constructor(message: string, options?: {
         middlewareId?: string;
         messageType?: string;

package/dist/domain/message/messageError.handler.js

@@ -7,7 +7,7 @@ import { MessageError } from "./messageError.base.js";
 export class MessageHandlerError extends MessageError {
     constructor(message, options) {
         super(message, {
-            code: ErrorCode.MESSAGE_HANDLER_NOT_FOUND,
+            code: ErrorCode.MESSAGE_HANDLER_FAILED,
             handlerId: options.handlerId,
             messageType: options.messageType,
             messageId: options.messageId,
@@ -19,40 +19,50 @@ export class MessageHandlerError extends MessageError {
 export function createMessageHandlerError(handlerId, messageType, messageId, cause) {
     return new MessageHandlerError(`Message handler "${handlerId}" failed while processing "${messageType}".`, { handlerId, messageType, messageId, cause });
 }
-/** Error thrown when a message handler cannot be found. */
+/**
+ * Error thrown when a message handler cannot be found.
+ *
+ * Handler registration is a server-side concern, so this is an internal
+ * (non-exposed, non-operational) failure.
+ */
 export class MessageHandlerNotFoundError extends MessageError {
     constructor(handlerId) {
         super(`Message handler "${handlerId}" was not found.`, {
-            code: ErrorCode.RESOURCE_NOT_FOUND,
+            code: ErrorCode.MESSAGE_HANDLER_NOT_FOUND,
             handlerId,
-            statusCode: 404,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
     }
 }
-/** Error thrown when a message handler is already registered. */
+/**
+ * Error thrown when a message handler is already registered.
+ *
+ * Handler registration is a server-side concern, so this is an internal
+ * (non-exposed, non-operational) failure.
+ */
 export class DuplicateMessageHandlerError extends MessageError {
     constructor(handlerId) {
         super(`Message handler "${handlerId}" is already registered.`, {
-            code: ErrorCode.CONFLICT,
+            code: ErrorCode.MESSAGE_DUPLICATE_HANDLER,
             handlerId,
-            statusCode: 409,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
     }
 }
 /** Error thrown when message middleware fails. */
 export class MessageMiddlewareError extends MessageError {
-    middlewareId;
     constructor(message, options = {}) {
         super(message, {
-            code: ErrorCode.MIDDLEWARE_EXECUTION,
+            code: ErrorCode.MESSAGE_MIDDLEWARE_FAILED,
             middlewareId: options.middlewareId,
             messageType: options.messageType,
             messageId: options.messageId,
             cause: options.cause,
         });
-        this.middlewareId = options.middlewareId;
     }
 }
 //# sourceMappingURL=messageError.handler.js.map

package/dist/domain/message/messageError.lifecycle.d.ts

@@ -14,7 +14,11 @@ export declare class InvalidMessageError extends MessageError {
         cause?: unknown;
     });
 }
-/** Error thrown when a message type is not registered. */
+/**
+ * Error thrown when a message type is not registered.
+ *
+ * Message registration is a server-side concern; reported as internal.
+ */
 export declare class MessageTypeNotFoundError extends MessageError {
     constructor(messageType: string);
 }

package/dist/domain/message/messageError.lifecycle.js

@@ -2,6 +2,7 @@
  * Message lifecycle error classes — dispatch, timeout, validation.
  */
 import { ErrorCode } from "../../base/types/errorCode.type.js";
+import { assertFiniteNonNegative } from "../shared/domainError.helpers.js";
 import { MessageError } from "./messageError.base.js";
 /** Error raised when message dispatch fails. */
 export class MessageDispatchError extends MessageError {
@@ -17,7 +18,7 @@ export class MessageDispatchError extends MessageError {
 export class InvalidMessageError extends MessageError {
     constructor(message, options = {}) {
         super(message, {
-            code: ErrorCode.INVALID_INPUT,
+            code: ErrorCode.MESSAGE_INVALID,
             messageType: options.messageType,
             messageId: options.messageId,
             cause: options.cause,
@@ -26,14 +27,19 @@ export class InvalidMessageError extends MessageError {
         });
     }
 }
-/** Error thrown when a message type is not registered. */
+/**
+ * Error thrown when a message type is not registered.
+ *
+ * Message registration is a server-side concern; reported as internal.
+ */
 export class MessageTypeNotFoundError extends MessageError {
     constructor(messageType) {
         super(`Message type "${messageType}" is not registered.`, {
-            code: ErrorCode.NOT_FOUND,
+            code: ErrorCode.MESSAGE_TYPE_NOT_FOUND,
             messageType,
-            statusCode: 404,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
     }
 }
@@ -41,7 +47,7 @@ export class MessageTypeNotFoundError extends MessageError {
 export class MessageDispatchAbortedError extends MessageError {
     constructor(message = "Message dispatch was aborted.", options = {}) {
         super(message, {
-            code: ErrorCode.OPERATION_CANCELLED,
+            code: ErrorCode.MESSAGE_ABORTED,
             messageType: options.messageType,
             messageId: options.messageId,
             statusCode: 499,
@@ -53,7 +59,7 @@ export class MessageDispatchAbortedError extends MessageError {
 export class MessageBusDisposedError extends MessageError {
     constructor() {
         super("Message bus has already been disposed.", {
-            code: ErrorCode.OPERATION_FAILED,
+            code: ErrorCode.MESSAGE_BUS_DISPOSED,
             statusCode: 500,
             isOperational: false,
         });
@@ -63,8 +69,9 @@ export class MessageBusDisposedError extends MessageError {
 export class MessageTimeoutError extends MessageError {
     timeoutMs;
     constructor(timeoutMs, options = {}) {
+        assertFiniteNonNegative("timeoutMs", timeoutMs);
         super(`Message processing exceeded the timeout of ${timeoutMs}ms.`, {
-            code: ErrorCode.TIMEOUT,
+            code: ErrorCode.MESSAGE_TIMEOUT,
             messageType: options.messageType,
             messageId: options.messageId,
             metadata: { timeoutMs },

package/dist/domain/message/messageError.serialization.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Message serialization and deserialization error classes.
+ */
+import { MessageError } from "./messageError.base.js";
+/** Error thrown when message serialization fails. */
+export declare class MessageSerializationError extends MessageError {
+    constructor(message: string, options?: {
+        messageType?: string;
+        messageId?: string;
+        cause?: unknown;
+    });
+}
+/**
+ * Error thrown when message deserialization fails.
+ *
+ * Malformed serialized input is a client/input problem, so this is a
+ * 400 that may be exposed.
+ */
+export declare class MessageDeserializationError extends MessageError {
+    constructor(message: string, options?: {
+        messageType?: string;
+        messageId?: string;
+        cause?: unknown;
+    });
+}
+//# sourceMappingURL=messageError.serialization.d.ts.map

package/dist/domain/message/messageError.serialization.js

@@ -0,0 +1,35 @@
+/**
+ * Message serialization and deserialization error classes.
+ */
+import { ErrorCode } from "../../base/types/errorCode.type.js";
+import { MessageError } from "./messageError.base.js";
+/** Error thrown when message serialization fails. */
+export class MessageSerializationError extends MessageError {
+    constructor(message, options = {}) {
+        super(message, {
+            code: ErrorCode.MESSAGE_SERIALIZATION_FAILED,
+            messageType: options.messageType,
+            messageId: options.messageId,
+            cause: options.cause,
+        });
+    }
+}
+/**
+ * Error thrown when message deserialization fails.
+ *
+ * Malformed serialized input is a client/input problem, so this is a
+ * 400 that may be exposed.
+ */
+export class MessageDeserializationError extends MessageError {
+    constructor(message, options = {}) {
+        super(message, {
+            code: ErrorCode.MESSAGE_DESERIALIZATION_FAILED,
+            messageType: options.messageType,
+            messageId: options.messageId,
+            cause: options.cause,
+            statusCode: 400,
+            expose: true,
+        });
+    }
+}
+//# sourceMappingURL=messageError.serialization.js.map

package/dist/domain/plugin/pluginError.lifecycle.js

@@ -3,6 +3,12 @@
  */
 import { ErrorCode } from "../../base/types/errorCode.type.js";
 import { PluginError } from "./pluginError.base.js";
+/*
+ * Plugin registration, lookup, dependency and state errors describe server
+ * configuration problems. They are reported as internal (500, not exposed,
+ * non-operational) so that plugin names and dependency graphs never reach
+ * clients and so that a misconfigured server is not blamed on the request.
+ */
 /** Error thrown when a plugin registration fails. */
 export class PluginRegistrationError extends PluginError {
     constructor(message, pluginName, options = {}) {
@@ -10,10 +16,10 @@ export class PluginRegistrationError extends PluginError {
             ...options,
             code: ErrorCode.PLUGIN_REGISTRATION,
             pluginName,
-            statusCode: 400,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
-        this.name = "PluginRegistrationError";
     }
 }
 /** Error thrown when a plugin is already registered. */
@@ -23,10 +29,10 @@ export class PluginAlreadyRegisteredError extends PluginError {
             ...options,
             code: ErrorCode.PLUGIN_ALREADY_REGISTERED,
             pluginName,
-            statusCode: 409,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
-        this.name = "PluginAlreadyRegisteredError";
     }
 }
 /** Error thrown when a plugin is not found. */
@@ -36,10 +42,10 @@ export class PluginNotFoundError extends PluginError {
             ...options,
             code: ErrorCode.PLUGIN_NOT_FOUND,
             pluginName,
-            statusCode: 404,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
-        this.name = "PluginNotFoundError";
     }
 }
 /** Error thrown when a plugin dependency is missing. */
@@ -49,11 +55,11 @@ export class PluginDependencyError extends PluginError {
             ...options,
             code: ErrorCode.PLUGIN_DEPENDENCY,
             pluginName,
-            statusCode: 400,
-            expose: true,
-            metadata: { dependencyName },
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
+            metadata: { ...options.metadata, dependencyName },
         });
-        this.name = "PluginDependencyError";
     }
 }
 /** Error thrown when a circular plugin dependency is detected. */
@@ -62,11 +68,11 @@ export class PluginDependencyCycleError extends PluginError {
         super(`Circular plugin dependency detected: ${cycle.join(" -> ")}.`, {
             ...options,
             code: ErrorCode.PLUGIN_DEPENDENCY_CYCLE,
-            statusCode: 400,
-            expose: true,
-            metadata: { cycle: [...cycle] },
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
+            metadata: { ...options.metadata, cycle: [...cycle] },
         });
-        this.name = "PluginDependencyCycleError";
     }
 }
 /** Error thrown when a plugin initialization fails. */
@@ -79,7 +85,6 @@ export class PluginInitializationError extends PluginError {
             statusCode: 500,
             expose: false,
         });
-        this.name = "PluginInitializationError";
     }
 }
 /** Error thrown when a plugin start fails. */
@@ -92,7 +97,6 @@ export class PluginStartError extends PluginError {
             statusCode: 500,
             expose: false,
         });
-        this.name = "PluginStartError";
     }
 }
 /** Error thrown when a plugin stop fails. */
@@ -105,7 +109,6 @@ export class PluginStopError extends PluginError {
             statusCode: 500,
             expose: false,
         });
-        this.name = "PluginStopError";
     }
 }
 /** Error thrown when a plugin dispose fails. */
@@ -118,7 +121,6 @@ export class PluginDisposeError extends PluginError {
             statusCode: 500,
             expose: false,
         });
-        this.name = "PluginDisposeError";
     }
 }
 //# sourceMappingURL=pluginError.lifecycle.js.map

package/dist/domain/plugin/pluginError.runtime.d.ts

@@ -6,7 +6,11 @@ import { PluginError, type PluginErrorOptions } from "./pluginError.base.js";
 export declare class PluginTimeoutError extends PluginError {
     constructor(pluginName: string, timeout: number, options?: PluginErrorOptions);
 }
-/** Error thrown when an invalid plugin state transition is attempted. */
+/**
+ * Error thrown when an invalid plugin state transition is attempted.
+ *
+ * Plugin state is server-side; reported as internal (500, not exposed).
+ */
 export declare class PluginStateError extends PluginError {
     constructor(pluginName: string, fromState: string, toState: string, options?: PluginErrorOptions);
 }

package/dist/domain/plugin/pluginError.runtime.js

@@ -2,33 +2,38 @@
  * Plugin runtime error classes — timeout, state transitions.
  */
 import { ErrorCode } from "../../base/types/errorCode.type.js";
+import { assertFiniteNonNegative } from "../shared/domainError.helpers.js";
 import { PluginError } from "./pluginError.base.js";
 /** Error thrown when a plugin operation times out. */
 export class PluginTimeoutError extends PluginError {
     constructor(pluginName, timeout, options = {}) {
+        assertFiniteNonNegative("timeout", timeout);
         super(`Plugin "${pluginName}" timed out after ${timeout}ms.`, {
             ...options,
             code: ErrorCode.PLUGIN_TIMEOUT,
             pluginName,
             statusCode: 504,
             expose: false,
-            metadata: { timeout },
+            metadata: { ...options.metadata, timeout },
         });
-        this.name = "PluginTimeoutError";
     }
 }
-/** Error thrown when an invalid plugin state transition is attempted. */
+/**
+ * Error thrown when an invalid plugin state transition is attempted.
+ *
+ * Plugin state is server-side; reported as internal (500, not exposed).
+ */
 export class PluginStateError extends PluginError {
     constructor(pluginName, fromState, toState, options = {}) {
         super(`Cannot transition plugin "${pluginName}" from "${fromState}" to "${toState}".`, {
             ...options,
             code: ErrorCode.PLUGIN_STATE,
             pluginName,
-            statusCode: 400,
-            expose: true,
-            metadata: { fromState, toState },
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
+            metadata: { ...options.metadata, fromState, toState },
         });
-        this.name = "PluginStateError";
     }
 }
 //# sourceMappingURL=pluginError.runtime.js.map

package/dist/domain/queue/queueError.base.d.ts

@@ -4,17 +4,36 @@
 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 { ErrorSeverity } from "../../base/types/errorSeverity.type.js";
 /** Options for creating a queue error. */
 export interface QueueErrorOptions extends Omit<BaseErrorOptions, "category"> {
     readonly category?: ErrorCategory;
     readonly queueName?: string;
     readonly jobId?: string;
+    readonly workerId?: string;
 }
 /** Base error for all queue subsystem failures. */
 export declare class QueueError extends BaseError {
     readonly queueName?: string;
     readonly jobId?: string;
+    readonly workerId?: string;
     constructor(message: string, options?: QueueErrorOptions);
+    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;
+        queueName?: string | undefined;
+        jobId?: string | undefined;
+        workerId?: string | undefined;
+    };
 }
 /** Check if an error is a QueueError. */
 export declare function isQueueError(error: unknown): error is QueueError;

package/dist/domain/queue/queueError.base.js

@@ -5,22 +5,43 @@ 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";
 /** Base error for all queue subsystem failures. */
 export class QueueError extends BaseError {
     queueName;
     jobId;
+    workerId;
     constructor(message, options = {}) {
         super(message, {
+            ...options,
             code: options.code ?? ErrorCode.QUEUE_ERROR,
             category: options.category ?? ErrorCategory.QUEUE,
             severity: options.severity ?? ErrorSeverity.WARNING,
-            cause: options.cause,
-            metadata: options.metadata,
+            statusCode: options.statusCode ?? 500,
             expose: options.expose ?? false,
             isOperational: options.isOperational ?? true,
+            metadata: {
+                ...options.metadata,
+                ...(options.queueName !== undefined
+                    ? { queueName: options.queueName }
+                    : {}),
+                ...(options.jobId !== undefined ? { jobId: options.jobId } : {}),
+                ...(options.workerId !== undefined
+                    ? { workerId: options.workerId }
+                    : {}),
+            },
         });
         this.queueName = options.queueName;
         this.jobId = options.jobId;
+        this.workerId = options.workerId;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            ...(this.queueName !== undefined ? { queueName: this.queueName } : {}),
+            ...(this.jobId !== undefined ? { jobId: this.jobId } : {}),
+            ...(this.workerId !== undefined ? { workerId: this.workerId } : {}),
+        };
     }
 }
 /** Check if an error is a QueueError. */
@@ -32,8 +53,7 @@ export function toQueueError(error, options = {}) {
     if (error instanceof QueueError) {
         return error;
     }
-    const message = error instanceof Error ? error.message : String(error);
-    return new QueueError(message, {
+    return new QueueError(safeErrorMessage(error), {
         cause: error,
         ...options,
     });

package/dist/domain/queue/queueError.job.js

@@ -2,6 +2,7 @@
  * Job-specific error classes.
  */
 import { ErrorCode } from "../../base/types/errorCode.type.js";
+import { assertFiniteNonNegative } from "../shared/domainError.helpers.js";
 import { QueueError } from "./queueError.base.js";
 /** Error thrown for general job failures. */
 export class JobError extends QueueError {
@@ -30,6 +31,7 @@ export class JobNotFoundError extends QueueError {
 export class JobTimeoutError extends QueueError {
     timeoutMs;
     constructor(jobId, timeoutMs, options = {}) {
+        assertFiniteNonNegative("timeoutMs", timeoutMs);
         super(`Job "${jobId}" exceeded the timeout of ${timeoutMs}ms.`, {
             code: ErrorCode.JOB_TIMEOUT,
             queueName: options.queueName,

package/dist/domain/queue/queueError.worker.d.ts

@@ -4,16 +4,22 @@
 import { QueueError } from "./queueError.base.js";
 /** Error thrown for worker failures. */
 export declare class WorkerError extends QueueError {
-    readonly workerId?: string;
     constructor(message: string, options?: {
         workerId?: string;
         queueName?: string;
         cause?: unknown;
     });
 }
-/** Error thrown when a worker is not found. */
+/**
+ * Error thrown when a worker is not found.
+ *
+ * Workers are server-side components, so this is reported as an internal
+ * failure and is not exposed to clients.
+ */
 export declare class WorkerNotFoundError extends QueueError {
-    constructor(workerId: string);
+    constructor(workerId: string, options?: {
+        queueName?: string;
+    });
 }
 /** Error thrown for worker lifecycle failures. */
 export declare class WorkerLifecycleError extends QueueError {

package/dist/domain/queue/queueError.worker.js

@@ -5,23 +5,30 @@ import { ErrorCode } from "../../base/types/errorCode.type.js";
 import { QueueError } from "./queueError.base.js";
 /** Error thrown for worker failures. */
 export class WorkerError extends QueueError {
-    workerId;
     constructor(message, options = {}) {
         super(message, {
             code: ErrorCode.WORKER_ERROR,
             queueName: options.queueName,
+            workerId: options.workerId,
             cause: options.cause,
         });
-        this.workerId = options.workerId;
     }
 }
-/** Error thrown when a worker is not found. */
+/**
+ * Error thrown when a worker is not found.
+ *
+ * Workers are server-side components, so this is reported as an internal
+ * failure and is not exposed to clients.
+ */
 export class WorkerNotFoundError extends QueueError {
-    constructor(workerId) {
+    constructor(workerId, options = {}) {
         super(`Worker "${workerId}" was not found.`, {
             code: ErrorCode.WORKER_NOT_FOUND,
-            statusCode: 404,
-            expose: true,
+            workerId,
+            queueName: options.queueName,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
     }
 }
@@ -31,6 +38,7 @@ export class WorkerLifecycleError extends QueueError {
         super(message, {
             code: ErrorCode.WORKER_LIFECYCLE,
             queueName: options.queueName,
+            workerId: options.workerId,
             cause: options.cause,
         });
     }

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

@@ -46,7 +46,6 @@ export class RPCProcedureNotFoundError extends RPCError {
             statusCode: 404,
             expose: true,
         });
-        this.name = "RPCProcedureNotFoundError";
     }
 }
 /** Error thrown when an RPC request is invalid. */
@@ -58,7 +57,6 @@ export class RPCInvalidRequestError extends RPCError {
             statusCode: 400,
             expose: true,
         });
-        this.name = "RPCInvalidRequestError";
     }
 }
 //# sourceMappingURL=rpcError.base.js.map