@lowdefy/errors 0.0.0-experimental-20260202125814

package/dist/build/ConfigError.js

@@ -0,0 +1,120 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import BaseConfigError from '../ConfigError.js';
+import ConfigMessage from './ConfigMessage.js';
+/**
+ * Build-time configuration error class.
+ * Extends base ConfigError with synchronous location resolution using keyMap/refMap.
+ * All formatting happens in the constructor - properties are ready for the logger.
+ *
+ * @example
+ * // Standard usage with message and context
+ * throw new ConfigError({
+ *   message: 'Connection id missing.',
+ *   configKey: block['~k'],
+ *   context,
+ * });
+ *
+ * @example
+ * // YAML parse error - pass error object instead of message
+ * throw new ConfigError({
+ *   error: yamlParseError,
+ *   filePath: 'lowdefy.yaml',
+ *   configDirectory,
+ * });
+ */ let ConfigError = class ConfigError extends BaseConfigError {
+    /**
+   * Creates a ConfigError instance with build-time formatting.
+   * All location resolution happens here - no format() method needed.
+   *
+   * @param {Object} params
+   * @param {string} [params.message] - The error message (or use params.error for YAML errors)
+   * @param {Error} [params.error] - Original error (for YAML parse errors - extracts line number)
+   * @param {string} [params.configKey] - Config key (~k) for keyMap lookup
+   * @param {Object} [params.operatorLocation] - { ref, line } for direct refMap lookup
+   * @param {string} [params.filePath] - Direct file path (for raw mode)
+   * @param {number|string} [params.lineNumber] - Direct line number (for raw mode)
+   * @param {Object} [params.context] - Build context with keyMap, refMap, directories
+   * @param {string} [params.configDirectory] - Config directory (for raw mode without context)
+   * @param {string} [params.checkSlug] - The specific check being performed
+   * @param {*} [params.received] - The value that caused the error (for logger to format)
+   */ constructor({ message, error, configKey, operatorLocation, filePath, lineNumber, context, configDirectory, checkSlug, received }){
+        // Handle YAML parse errors - extract line number from error message
+        let finalMessage = message;
+        let finalLineNumber = lineNumber;
+        if (error instanceof Error) {
+            finalMessage = `Could not parse YAML. ${error.message}`;
+            const lineMatch = error.message.match(/at line (\d+)/);
+            finalLineNumber = lineMatch ? lineMatch[1] : null;
+        }
+        // Call base constructor with minimal info first
+        super({
+            message: finalMessage,
+            configKey,
+            checkSlug
+        });
+        // Store all properties for the logger
+        this.configKey = configKey ?? null;
+        this.checkSlug = checkSlug;
+        this.operatorLocation = operatorLocation;
+        this.received = received;
+        // Check for ~ignoreBuildChecks suppression
+        this.suppressed = ConfigMessage.shouldSuppress({
+            configKey,
+            keyMap: context?.keyMap,
+            checkSlug
+        });
+        if (this.suppressed) {
+            this.message = '';
+            this.source = null;
+            this.config = null;
+            this.link = null;
+            this.resolved = true;
+            return;
+        }
+        // Resolve location based on available info
+        let location = null;
+        const configDir = configDirectory ?? context?.directories?.config;
+        if (configKey && context?.keyMap) {
+            // Mode 1: Use configKey -> keyMap -> refMap path (standard case after addKeys)
+            location = ConfigMessage.resolveLocation({
+                configKey,
+                context
+            });
+        } else if (operatorLocation && context?.refMap) {
+            // Mode 2: Use operatorLocation directly with refMap (early build stages)
+            location = ConfigMessage.resolveOperatorLocation({
+                operatorLocation,
+                context
+            });
+        } else if (filePath) {
+            // Mode 3: Use raw filePath/lineNumber (YAML parse errors, etc.)
+            location = ConfigMessage.resolveRawLocation({
+                filePath,
+                lineNumber: finalLineNumber,
+                configDirectory: configDir
+            });
+        }
+        // Set location properties
+        this.source = location?.source ?? null;
+        this.config = location?.config ?? null;
+        this.link = location?.link ?? null;
+        // Set message (no prefix - logger uses error.name for display)
+        this.message = finalMessage;
+        // Mark as resolved
+        this.resolved = true;
+    }
+};
+export default ConfigError;

package/dist/build/ConfigMessage.js

@@ -0,0 +1,122 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import path from 'path';
+import resolveConfigLocation from './resolveConfigLocation.js';
+/**
+ * Valid check slugs for ~ignoreBuildChecks.
+ * Keys are the slug names, values are descriptions for error messages.
+ * These suppress BUILD-TIME validation only - runtime errors still occur.
+ */ export const VALID_CHECK_SLUGS = {
+    'state-refs': 'Undefined _state reference warnings',
+    'payload-refs': 'Undefined _payload reference warnings',
+    'step-refs': 'Undefined _step reference warnings',
+    'link-refs': 'Invalid Link action page reference warnings',
+    'request-refs': 'Invalid Request action reference warnings',
+    'connection-refs': 'Nonexistent connection ID references',
+    types: 'All type validation (blocks, operators, actions, requests, connections)',
+    schema: 'JSON schema validation errors'
+};
+/**
+ * Base class for config message utilities.
+ * Provides shared utilities for ConfigError and ConfigWarning.
+ */ let ConfigMessage = class ConfigMessage {
+    /**
+   * Checks if a message should be suppressed based on ~ignoreBuildChecks.
+   * Walks up the parent chain looking for suppressions that cover this check.
+   * This walk happens ONLY when an error/warning is about to be logged.
+   *
+   * @param {Object} params
+   * @param {string} params.configKey - Config key (~k) of the error location
+   * @param {Object} params.keyMap - The keyMap from build context
+   * @param {string} [params.checkSlug] - The specific check being performed (e.g., 'state-refs')
+   * @returns {boolean} True if message should be suppressed
+   */ static shouldSuppress({ configKey, keyMap, checkSlug }) {
+        if (!configKey || !keyMap) return false;
+        let currentKey = configKey;
+        let depth = 0;
+        const MAX_DEPTH = 100; // Guard against circular parents
+        while(currentKey && depth < MAX_DEPTH){
+            const entry = keyMap[currentKey];
+            if (!entry) break;
+            const ignoredChecks = entry['~ignoreBuildChecks'];
+            if (ignoredChecks === true) {
+                return true;
+            }
+            if (Array.isArray(ignoredChecks) && checkSlug && ignoredChecks.includes(checkSlug)) {
+                return true;
+            }
+            currentKey = entry['~k_parent'];
+            depth++;
+        }
+        return false;
+    }
+    /**
+   * Resolves location from configKey using keyMap and refMap.
+   * @param {Object} params
+   * @param {string} params.configKey - Config key (~k) for keyMap lookup
+   * @param {Object} params.context - Build context with keyMap, refMap, directories
+   * @returns {Object|null} Location object { source, config, link } or null
+   */ static resolveLocation({ configKey, context }) {
+        if (!configKey || !context?.keyMap) return null;
+        return resolveConfigLocation({
+            configKey,
+            keyMap: context.keyMap,
+            refMap: context.refMap,
+            configDirectory: context.directories?.config
+        });
+    }
+    /**
+   * Resolves location directly from operatorLocation (ref + line) without keyMap.
+   * Used during early build stages (buildRefs) when keyMap doesn't exist yet.
+   * @param {Object} params
+   * @param {Object} params.operatorLocation - { ref, line }
+   * @param {Object} params.context - Build context with refMap, directories
+   * @returns {Object|null} Location object { source, link } or null
+   */ static resolveOperatorLocation({ operatorLocation, context }) {
+        if (!operatorLocation) return null;
+        const refEntry = context?.refMap?.[operatorLocation.ref];
+        const filePath = refEntry?.path ?? 'lowdefy.yaml';
+        const lineNumber = operatorLocation.line;
+        const source = lineNumber ? `${filePath}:${lineNumber}` : filePath;
+        let link = null;
+        if (context?.directories?.config) {
+            link = path.join(context.directories.config, filePath) + (lineNumber ? `:${lineNumber}` : '');
+        }
+        return {
+            source,
+            link
+        };
+    }
+    /**
+   * Resolves location from raw filePath and lineNumber.
+   * Used for YAML parse errors and other cases without config context.
+   * @param {Object} params
+   * @param {string} params.filePath - Direct file path
+   * @param {number|string} [params.lineNumber] - Direct line number
+   * @param {string} [params.configDirectory] - Config directory for link
+   * @returns {Object} Location object { source, link }
+   */ static resolveRawLocation({ filePath, lineNumber, configDirectory }) {
+        const source = lineNumber ? `${filePath}:${lineNumber}` : filePath;
+        let link = null;
+        if (configDirectory) {
+            link = path.join(configDirectory, filePath) + (lineNumber ? `:${lineNumber}` : '');
+        }
+        return {
+            source,
+            link
+        };
+    }
+};
+export default ConfigMessage;

package/dist/build/ConfigWarning.js

@@ -0,0 +1,104 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import ConfigError from './ConfigError.js';
+import ConfigMessage from './ConfigMessage.js';
+/**
+ * Build-time configuration warning class.
+ * All formatting happens in the constructor - properties are ready for the logger.
+ *
+ * In development: Creates a warning with source and message properties
+ * In production with prodError: Throws ConfigError instead
+ *
+ * @example
+ * const warning = new ConfigWarning({ message, configKey, context });
+ * if (!warning.suppressed) {
+ *   logger.warn({ source: warning.source }, warning.message);
+ * }
+ *
+ * @example
+ * // Throws ConfigError in prod mode when prodError is true
+ * new ConfigWarning({ message, configKey, context, prodError: true });
+ */ let ConfigWarning = class ConfigWarning {
+    /**
+   * @param {Object} params
+   * @param {string} params.message - The warning message
+   * @param {string} [params.configKey] - Config key (~k) for location resolution
+   * @param {Object} [params.operatorLocation] - { ref, line } for direct refMap lookup
+   * @param {string} [params.filePath] - Direct file path (for raw mode)
+   * @param {number|string} [params.lineNumber] - Direct line number (for raw mode)
+   * @param {Object} [params.context] - Build context with keyMap, refMap, directories, stage
+   * @param {string} [params.configDirectory] - Config directory (for raw mode without context)
+   * @param {string} [params.checkSlug] - The specific check being performed (e.g., 'state-refs')
+   * @param {boolean} [params.prodError] - If true, throw ConfigError in prod mode
+   * @param {*} [params.received] - The value that caused the warning (for logger to format)
+   * @throws {ConfigError} When prodError is true and context.stage is 'prod'
+   */ constructor({ message, configKey, operatorLocation, filePath, lineNumber, context, configDirectory, checkSlug, prodError, received }){
+        // In prod mode with prodError flag, throw ConfigError instead
+        if (prodError && context?.stage === 'prod') {
+            throw new ConfigError({
+                message,
+                configKey,
+                operatorLocation,
+                context,
+                checkSlug,
+                received
+            });
+        }
+        // Store all properties for the logger
+        this.configKey = configKey ?? null;
+        this.checkSlug = checkSlug;
+        this.received = received;
+        // Check for ~ignoreBuildChecks suppression
+        this.suppressed = ConfigMessage.shouldSuppress({
+            configKey,
+            keyMap: context?.keyMap,
+            checkSlug
+        });
+        if (this.suppressed) {
+            this.message = '';
+            this.source = null;
+            this.config = null;
+            this.link = null;
+            return;
+        }
+        // Resolve location based on available info
+        let location = null;
+        const configDir = configDirectory ?? context?.directories?.config;
+        if (configKey && context?.keyMap) {
+            location = ConfigMessage.resolveLocation({
+                configKey,
+                context
+            });
+        } else if (operatorLocation && context?.refMap) {
+            location = ConfigMessage.resolveOperatorLocation({
+                operatorLocation,
+                context
+            });
+        } else if (filePath) {
+            location = ConfigMessage.resolveRawLocation({
+                filePath,
+                lineNumber,
+                configDirectory: configDir
+            });
+        }
+        // Set location properties
+        this.source = location?.source ?? null;
+        this.config = location?.config ?? null;
+        this.link = location?.link ?? null;
+        // Set message (no prefix - logger uses class name for display)
+        this.message = message;
+    }
+};
+export default ConfigWarning;

package/dist/build/index.js

@@ -0,0 +1,37 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ /**
+ * @lowdefy/errors/build - Build-time error classes.
+ *
+ * Use this entry point for build-time code that needs synchronous location resolution
+ * using keyMap and refMap from the build context.
+ *
+ * @example
+ * import { ConfigError, ConfigWarning, ConfigMessage } from '@lowdefy/errors/build';
+ *
+ * throw new ConfigError({
+ *   message: 'Connection id missing.',
+ *   configKey: block['~k'],
+ *   context,
+ * });
+ */ import ConfigError from './ConfigError.js';
+import ConfigWarning from './ConfigWarning.js';
+import ConfigMessage, { VALID_CHECK_SLUGS } from './ConfigMessage.js';
+import resolveConfigLocation from './resolveConfigLocation.js';
+import resolveErrorConfigLocation from './resolveErrorConfigLocation.js';
+import LowdefyError from '../LowdefyError.js';
+import PluginError from '../PluginError.js';
+import ServiceError from '../ServiceError.js';
+export { ConfigError, ConfigMessage, ConfigWarning, LowdefyError, PluginError, resolveConfigLocation, resolveErrorConfigLocation, ServiceError, VALID_CHECK_SLUGS };

package/dist/build/resolveConfigLocation.js

@@ -0,0 +1,63 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import path from 'path';
+/**
+ * Resolves a config key (~k) to source and config location.
+ *
+ * @param {Object} params
+ * @param {string} params.configKey - The ~k value from the config object
+ * @param {Object} params.keyMap - The keyMap from build output
+ * @param {Object} params.refMap - The refMap from build output
+ * @param {string} [params.configDirectory] - Absolute path to config directory for clickable links
+ * @returns {Object|null} Location object with source, config, and link, or null if not resolvable
+ *
+ * @example
+ * const location = resolveConfigLocation({
+ *   configKey: 'abc123',
+ *   keyMap: { 'abc123': { key: 'root.pages[0:home].blocks[0:header]', '~r': 'ref1', '~l': 5 } },
+ *   refMap: { 'ref1': { path: 'pages/home.yaml' } },
+ *   configDirectory: '/Users/dev/myapp'
+ * });
+ * // Returns: {
+ * //   source: 'pages/home.yaml:5',
+ * //   config: 'root.pages[0:home].blocks[0:header]',
+ * //   link: '/Users/dev/myapp/pages/home.yaml:5'
+ * // }
+ */ function resolveConfigLocation({ configKey, keyMap, refMap, configDirectory }) {
+    if (!configKey || !keyMap || !keyMap[configKey]) {
+        return null;
+    }
+    const keyEntry = keyMap[configKey];
+    const refId = keyEntry['~r'];
+    const lineNumber = keyEntry['~l'];
+    const refEntry = refMap?.[refId];
+    const filePath = refEntry?.path || 'lowdefy.yaml';
+    // source: filepath:line (e.g., "lowdefy.yaml:16")
+    const source = lineNumber ? `${filePath}:${lineNumber}` : filePath;
+    // config: the config path (e.g., "root.pages[0:home].blocks[0:header]")
+    const config = keyEntry.key;
+    // Absolute path for clickable links in VSCode terminal
+    let link = null;
+    if (configDirectory) {
+        const absolutePath = path.resolve(configDirectory, filePath);
+        link = lineNumber ? `${absolutePath}:${lineNumber}` : absolutePath;
+    }
+    return {
+        source,
+        config,
+        link
+    };
+}
+export default resolveConfigLocation;

package/dist/build/resolveErrorConfigLocation.js

@@ -0,0 +1,45 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import resolveConfigLocation from './resolveConfigLocation.js';
+/**
+ * Resolves error config location at runtime by reading keyMap and refMap files.
+ * Used by server-side error logging to trace errors back to source files.
+ *
+ * @param {Object} params
+ * @param {Object} params.error - Error object with optional configKey property
+ * @param {Function} params.readConfigFile - Async function to read config files
+ * @param {string} params.configDirectory - Absolute path to config directory
+ * @returns {Promise<Object|null>} Location object with source, config, and link, or null
+ */ async function resolveErrorConfigLocation({ error, readConfigFile, configDirectory }) {
+    if (!error?.configKey) {
+        return null;
+    }
+    try {
+        const [keyMap, refMap] = await Promise.all([
+            readConfigFile('keyMap.json'),
+            readConfigFile('refMap.json')
+        ]);
+        const location = resolveConfigLocation({
+            configKey: error.configKey,
+            keyMap,
+            refMap,
+            configDirectory
+        });
+        return location || null;
+    } catch  {
+        return null;
+    }
+}
+export default resolveErrorConfigLocation;

package/dist/client/ConfigError.js

@@ -0,0 +1,79 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import BaseConfigError from '../ConfigError.js';
+/**
+ * Client-side ConfigError with async location resolution via API.
+ *
+ * Extends the base ConfigError to add async resolution that calls
+ * the /api/client-error endpoint to resolve configKey to file:line.
+ *
+ * @example
+ * const error = new ConfigError({ message: 'Invalid operator', configKey });
+ * await error.resolve(lowdefy);
+ * console.error(error.source); // "pages/home.yaml:42"
+ * console.error(error.message); // "Invalid operator"
+ */ let ConfigError = class ConfigError extends BaseConfigError {
+    /**
+   * Resolves location from server (async).
+   * Updates this.message with the resolved location.
+   * @param {Object} lowdefy - Lowdefy context with basePath and pageId
+   * @param {Object} [options]
+   * @param {number} [options.timeout=1000] - Fetch timeout in ms
+   * @returns {Promise<ConfigError>} Returns this for chaining
+   */ async resolve(lowdefy, { timeout = 1000 } = {}) {
+        // basePath can be empty string "" which is valid (no custom base path)
+        if (this.resolved || lowdefy?.basePath === undefined) {
+            this.resolved = true;
+            return this;
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(()=>controller.abort(), timeout);
+        try {
+            const response = await fetch(`${lowdefy.basePath}/api/client-error`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(this.serialize()),
+                signal: controller.signal,
+                credentials: 'same-origin'
+            });
+            clearTimeout(timeoutId);
+            if (response.ok) {
+                const result = await response.json();
+                this.source = result.source;
+                this.config = result.config;
+                this.link = result.link;
+            }
+        } catch  {
+            clearTimeout(timeoutId);
+        // Resolution failed (timeout or network error) - continue without location
+        }
+        this.resolved = true;
+        return this;
+    }
+    /**
+   * Resolves location (if not already resolved) and logs to console.
+   * @param {Object} [lowdefy] - Lowdefy context for resolution
+   * @param {Object} [options] - Options for resolution
+   * @returns {Promise<void>}
+   */ async log(lowdefy, options) {
+        if (!this.resolved && lowdefy) {
+            await this.resolve(lowdefy, options);
+        }
+        console.error(this.message);
+    }
+};
+export default ConfigError;

package/dist/client/index.js

@@ -0,0 +1,30 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ /**
+ * @lowdefy/errors/client - Client-side error classes.
+ *
+ * Use this entry point for client-side (browser) code that needs async location resolution.
+ *
+ * @example
+ * import { ConfigError, PluginError } from '@lowdefy/errors/client';
+ *
+ * const error = new ConfigError({ message: 'Invalid operator', configKey });
+ * await error.resolve(lowdefy);
+ */ import ConfigError from './ConfigError.js';
+import ConfigWarning from '../ConfigWarning.js';
+import LowdefyError from '../LowdefyError.js';
+import PluginError from '../PluginError.js';
+import ServiceError from '../ServiceError.js';
+export { ConfigError, ConfigWarning, LowdefyError, PluginError, ServiceError };

package/dist/deserializeError.js

@@ -0,0 +1,36 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import ConfigError from './ConfigError.js';
+import LowdefyError from './LowdefyError.js';
+import PluginError from './PluginError.js';
+import ServiceError from './ServiceError.js';
+const errorTypes = {
+    ConfigError,
+    LowdefyError,
+    PluginError,
+    ServiceError
+};
+/**
+ * Deserializes error data back into the appropriate error class.
+ * @param {Object} data - Serialized error data with ~err type marker
+ * @returns {Error} The deserialized error instance
+ */ function deserializeError(data) {
+    const ErrorClass = errorTypes[data['~err']];
+    if (!ErrorClass) {
+        throw new Error(`Unknown error type: ${data['~err']}`);
+    }
+    return ErrorClass.deserialize(data);
+}
+export default deserializeError;