@futdevpro/fsm-dynamo 1.16.39 → 1.20.2

package/build/_collections/utils/data.util.js

@@ -1,208 +1,208 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyFM_Data = void 0;
-const data_sizes_const_1 = require("../constants/data-sizes.const");
-const math_util_1 = require("./math/math.util");
-/**
- * Data utility class
- *
- * Hungarian documentation (Hunglish):
- * - Ez a utility data-size konverziókra fókuszál, ember-barát string formátummal
- * - A számítás 1024-es alapot használ (KB/MB/GB/TB)
- * - A `getSizeString` adja vissza a rövidített formátumot, pl.: `1.5KB`, `12MB`, `1GB 256MB`
- */
-class DyFM_Data {
-    /**
-     * A kilobyte (1024 B) egység
-     */
-    static kilobyte = data_sizes_const_1.kilobyte;
-    /**
-     * A megabyte (1024 KB) egység
-     */
-    static megabyte = data_sizes_const_1.megabyte;
-    /**
-     * A gigabyte (1024 MB) egység
-     */
-    static gigabyte = data_sizes_const_1.gigabyte;
-    /**
-     * A terabyte (1024 GB) egység
-     */
-    static terabyte = data_sizes_const_1.terabyte;
-    /**
-     * A petabyte (1024 TB) egység
-     */
-    static petabyte = data_sizes_const_1.petabyte;
-    /**
-     * A exabyte (1024 PB) egység
-     */
-    static exabyte = data_sizes_const_1.exabyte;
-    /**
-     * A zettabyte (1024 EB) egység
-     */
-    static zettabyte = data_sizes_const_1.zettabyte;
-    /**
-     * A yottabyte (1024 ZB) egység
-     */
-    static yottabyte = data_sizes_const_1.yottabyte;
-    /**
-     * Size-et ad vissza ember-barát string-ként.
-     * - 1024-es váltószámot használunk (KB/MB/GB/TB)
-     * - Negatív értékeknél `-` jel kerül az elejére (abszolút értékkel számolunk)
-     * - `full=true` esetén a következő kisebb egység maradéka is megjelenik (pl. `1GB 256MB`)
-     *
-     * Példák:
-     * ```ts
-     * DyFM_Data.getSizeString(0);               // '0B'
-     * DyFM_Data.getSizeString(1536);            // '1.5KB'
-     * DyFM_Data.getSizeString(1536, 0, true);   // '2KB 0B'
-     * DyFM_Data.getSizeString(1_234_567);       // '1.18MB'
-     * DyFM_Data.getSizeString(1_234_567, 0);    // '1MB'
-     * DyFM_Data.getSizeString(1_500_000_000);   // '1.4GB'
-     * ```
-     */
-    static getSizeString(size, decimals, full) {
-        // Edge case: 0 → rögtön visszaadjuk
-        if (size === 0) {
-            return '0B';
-        }
-        if (!size) {
-            return 'N/A';
-        }
-        // Negatív jel kezelése, számítás abszolút értékkel
-        const isNegative = size < 0;
-        let remaining = Math.abs(size);
-        // < 1KB → B (decimals nélkül)
-        if (remaining < this.kilobyte) {
-            const sign = isNegative ? '-' : '';
-            return `${sign}${Math.floor(remaining)}B`;
-        }
-        // KB
-        if (remaining < this.megabyte) {
-            const kb = remaining / this.kilobyte;
-            if (full) {
-                const kbWhole = Math.floor(kb);
-                const remainderAfterKb = remaining - (kbWhole * this.kilobyte);
-                const bRemainder = Math.floor(remainderAfterKb);
-                const sign = isNegative ? '-' : '';
-                if (bRemainder > 0) {
-                    return `${sign}${kbWhole}KB ${bRemainder}B`;
-                }
-                return `${sign}${kbWhole}KB`;
-            }
-            const str = `${math_util_1.DyFM_Math.round(kb, decimals ?? (Number.isInteger(kb) ? 0 : 2))}KB`;
-            return isNegative ? `-${str}` : str;
-        }
-        // MB
-        if (remaining < this.gigabyte) {
-            const mb = remaining / this.megabyte;
-            if (full) {
-                const mbWhole = Math.floor(mb);
-                const remainderAfterMb = remaining - (mbWhole * this.megabyte);
-                const kbRemainder = Math.floor(remainderAfterMb / this.kilobyte);
-                const sign = isNegative ? '-' : '';
-                if (kbRemainder > 0) {
-                    return `${sign}${mbWhole}MB ${kbRemainder}KB`;
-                }
-                return `${sign}${mbWhole}MB`;
-            }
-            const str = `${math_util_1.DyFM_Math.round(mb, decimals ?? (Number.isInteger(mb) ? 0 : 2))}MB`;
-            return isNegative ? `-${str}` : str;
-        }
-        // GB
-        if (remaining < this.terabyte) {
-            const gb = remaining / this.gigabyte;
-            if (full) {
-                const gbWhole = Math.floor(gb);
-                const remainderAfterGb = remaining - (gbWhole * this.gigabyte);
-                const mbRemainder = Math.floor(remainderAfterGb / this.megabyte);
-                const sign = isNegative ? '-' : '';
-                if (mbRemainder > 0) {
-                    return `${sign}${gbWhole}GB ${mbRemainder}MB`;
-                }
-                return `${sign}${gbWhole}GB`;
-            }
-            const str = `${math_util_1.DyFM_Math.round(gb, decimals ?? (Number.isInteger(gb) ? 0 : 2))}GB`;
-            return isNegative ? `-${str}` : str;
-        }
-        // TB
-        if (remaining < this.petabyte) {
-            const tb = remaining / this.terabyte;
-            if (full) {
-                const tbWhole = Math.floor(tb);
-                const remainderAfterTb = remaining - (tbWhole * this.terabyte);
-                const gbRemainder = Math.floor(remainderAfterTb / this.gigabyte);
-                const sign = isNegative ? '-' : '';
-                if (gbRemainder > 0) {
-                    return `${sign}${tbWhole}TB ${gbRemainder}GB`;
-                }
-                return `${sign}${tbWhole}TB`;
-            }
-            const str = `${math_util_1.DyFM_Math.round(tb, decimals ?? (Number.isInteger(tb) ? 0 : 2))}TB`;
-            return isNegative ? `-${str}` : str;
-        }
-        // PB
-        if (remaining < this.exabyte) {
-            const pb = remaining / this.petabyte;
-            if (full) {
-                const pbWhole = Math.floor(pb);
-                const remainderAfterPb = remaining - (pbWhole * this.petabyte);
-                const tbRemainder = Math.floor(remainderAfterPb / this.terabyte);
-                const sign = isNegative ? '-' : '';
-                if (tbRemainder > 0) {
-                    return `${sign}${pbWhole}PB ${tbRemainder}TB`;
-                }
-                return `${sign}${pbWhole}PB`;
-            }
-            const str = `${math_util_1.DyFM_Math.round(pb, decimals ?? (Number.isInteger(pb) ? 0 : 2))}PB`;
-            return isNegative ? `-${str}` : str;
-        }
-        // EB
-        if (remaining < this.zettabyte) {
-            const eb = remaining / this.exabyte;
-            if (full) {
-                const ebWhole = Math.floor(eb);
-                const remainderAfterEb = remaining - (ebWhole * this.exabyte);
-                const pbRemainder = Math.floor(remainderAfterEb / this.petabyte);
-                const sign = isNegative ? '-' : '';
-                if (pbRemainder > 0) {
-                    return `${sign}${ebWhole}EB ${pbRemainder}PB`;
-                }
-                return `${sign}${ebWhole}EB`;
-            }
-            const str = `${math_util_1.DyFM_Math.round(eb, decimals ?? (Number.isInteger(eb) ? 0 : 2))}EB`;
-            return isNegative ? `-${str}` : str;
-        }
-        // ZB
-        if (remaining < this.yottabyte) {
-            const zb = remaining / this.zettabyte;
-            if (full) {
-                const zbWhole = Math.floor(zb);
-                const remainderAfterZb = remaining - (zbWhole * this.zettabyte);
-                const ebRemainder = Math.floor(remainderAfterZb / this.exabyte);
-                const sign = isNegative ? '-' : '';
-                if (ebRemainder > 0) {
-                    return `${sign}${zbWhole}ZB ${ebRemainder}EB`;
-                }
-                return `${sign}${zbWhole}ZB`;
-            }
-            const str = `${math_util_1.DyFM_Math.round(zb, decimals ?? (Number.isInteger(zb) ? 0 : 2))}ZB`;
-            return isNegative ? `-${str}` : str;
-        }
-        // YB
-        const yb = remaining / this.yottabyte;
-        if (full) {
-            const ybWhole = Math.floor(yb);
-            const remainderAfterYb = remaining - (ybWhole * this.yottabyte);
-            const zbRemainder = Math.floor(remainderAfterYb / this.zettabyte);
-            const sign = isNegative ? '-' : '';
-            if (zbRemainder > 0) {
-                return `${sign}${ybWhole}YB ${zbRemainder}ZB`;
-            }
-            return `${sign}${ybWhole}YB`;
-        }
-        const str = `${math_util_1.DyFM_Math.round(yb, decimals ?? (Number.isInteger(yb) ? 0 : 2))}YB`;
-        return isNegative ? `-${str}` : str;
-    }
-}
-exports.DyFM_Data = DyFM_Data;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyFM_Data = void 0;
+const data_sizes_const_1 = require("../constants/data-sizes.const");
+const math_util_1 = require("./math/math.util");
+/**
+ * Data utility class
+ *
+ * Hungarian documentation (Hunglish):
+ * - Ez a utility data-size konverziókra fókuszál, ember-barát string formátummal
+ * - A számítás 1024-es alapot használ (KB/MB/GB/TB)
+ * - A `getSizeString` adja vissza a rövidített formátumot, pl.: `1.5KB`, `12MB`, `1GB 256MB`
+ */
+class DyFM_Data {
+    /**
+     * A kilobyte (1024 B) egység
+     */
+    static kilobyte = data_sizes_const_1.kilobyte;
+    /**
+     * A megabyte (1024 KB) egység
+     */
+    static megabyte = data_sizes_const_1.megabyte;
+    /**
+     * A gigabyte (1024 MB) egység
+     */
+    static gigabyte = data_sizes_const_1.gigabyte;
+    /**
+     * A terabyte (1024 GB) egység
+     */
+    static terabyte = data_sizes_const_1.terabyte;
+    /**
+     * A petabyte (1024 TB) egység
+     */
+    static petabyte = data_sizes_const_1.petabyte;
+    /**
+     * A exabyte (1024 PB) egység
+     */
+    static exabyte = data_sizes_const_1.exabyte;
+    /**
+     * A zettabyte (1024 EB) egység
+     */
+    static zettabyte = data_sizes_const_1.zettabyte;
+    /**
+     * A yottabyte (1024 ZB) egység
+     */
+    static yottabyte = data_sizes_const_1.yottabyte;
+    /**
+     * Size-et ad vissza ember-barát string-ként.
+     * - 1024-es váltószámot használunk (KB/MB/GB/TB)
+     * - Negatív értékeknél `-` jel kerül az elejére (abszolút értékkel számolunk)
+     * - `full=true` esetén a következő kisebb egység maradéka is megjelenik (pl. `1GB 256MB`)
+     *
+     * Példák:
+     * ```ts
+     * DyFM_Data.getSizeString(0);               // '0B'
+     * DyFM_Data.getSizeString(1536);            // '1.5KB'
+     * DyFM_Data.getSizeString(1536, 0, true);   // '2KB 0B'
+     * DyFM_Data.getSizeString(1_234_567);       // '1.18MB'
+     * DyFM_Data.getSizeString(1_234_567, 0);    // '1MB'
+     * DyFM_Data.getSizeString(1_500_000_000);   // '1.4GB'
+     * ```
+     */
+    static getSizeString(size, decimals, full) {
+        // Edge case: 0 → rögtön visszaadjuk
+        if (size === 0) {
+            return '0B';
+        }
+        if (!size) {
+            return 'N/A';
+        }
+        // Negatív jel kezelése, számítás abszolút értékkel
+        const isNegative = size < 0;
+        let remaining = Math.abs(size);
+        // < 1KB → B (decimals nélkül)
+        if (remaining < this.kilobyte) {
+            const sign = isNegative ? '-' : '';
+            return `${sign}${Math.floor(remaining)}B`;
+        }
+        // KB
+        if (remaining < this.megabyte) {
+            const kb = remaining / this.kilobyte;
+            if (full) {
+                const kbWhole = Math.floor(kb);
+                const remainderAfterKb = remaining - (kbWhole * this.kilobyte);
+                const bRemainder = Math.floor(remainderAfterKb);
+                const sign = isNegative ? '-' : '';
+                if (bRemainder > 0) {
+                    return `${sign}${kbWhole}KB ${bRemainder}B`;
+                }
+                return `${sign}${kbWhole}KB`;
+            }
+            const str = `${math_util_1.DyFM_Math.round(kb, decimals ?? (Number.isInteger(kb) ? 0 : 2))}KB`;
+            return isNegative ? `-${str}` : str;
+        }
+        // MB
+        if (remaining < this.gigabyte) {
+            const mb = remaining / this.megabyte;
+            if (full) {
+                const mbWhole = Math.floor(mb);
+                const remainderAfterMb = remaining - (mbWhole * this.megabyte);
+                const kbRemainder = Math.floor(remainderAfterMb / this.kilobyte);
+                const sign = isNegative ? '-' : '';
+                if (kbRemainder > 0) {
+                    return `${sign}${mbWhole}MB ${kbRemainder}KB`;
+                }
+                return `${sign}${mbWhole}MB`;
+            }
+            const str = `${math_util_1.DyFM_Math.round(mb, decimals ?? (Number.isInteger(mb) ? 0 : 2))}MB`;
+            return isNegative ? `-${str}` : str;
+        }
+        // GB
+        if (remaining < this.terabyte) {
+            const gb = remaining / this.gigabyte;
+            if (full) {
+                const gbWhole = Math.floor(gb);
+                const remainderAfterGb = remaining - (gbWhole * this.gigabyte);
+                const mbRemainder = Math.floor(remainderAfterGb / this.megabyte);
+                const sign = isNegative ? '-' : '';
+                if (mbRemainder > 0) {
+                    return `${sign}${gbWhole}GB ${mbRemainder}MB`;
+                }
+                return `${sign}${gbWhole}GB`;
+            }
+            const str = `${math_util_1.DyFM_Math.round(gb, decimals ?? (Number.isInteger(gb) ? 0 : 2))}GB`;
+            return isNegative ? `-${str}` : str;
+        }
+        // TB
+        if (remaining < this.petabyte) {
+            const tb = remaining / this.terabyte;
+            if (full) {
+                const tbWhole = Math.floor(tb);
+                const remainderAfterTb = remaining - (tbWhole * this.terabyte);
+                const gbRemainder = Math.floor(remainderAfterTb / this.gigabyte);
+                const sign = isNegative ? '-' : '';
+                if (gbRemainder > 0) {
+                    return `${sign}${tbWhole}TB ${gbRemainder}GB`;
+                }
+                return `${sign}${tbWhole}TB`;
+            }
+            const str = `${math_util_1.DyFM_Math.round(tb, decimals ?? (Number.isInteger(tb) ? 0 : 2))}TB`;
+            return isNegative ? `-${str}` : str;
+        }
+        // PB
+        if (remaining < this.exabyte) {
+            const pb = remaining / this.petabyte;
+            if (full) {
+                const pbWhole = Math.floor(pb);
+                const remainderAfterPb = remaining - (pbWhole * this.petabyte);
+                const tbRemainder = Math.floor(remainderAfterPb / this.terabyte);
+                const sign = isNegative ? '-' : '';
+                if (tbRemainder > 0) {
+                    return `${sign}${pbWhole}PB ${tbRemainder}TB`;
+                }
+                return `${sign}${pbWhole}PB`;
+            }
+            const str = `${math_util_1.DyFM_Math.round(pb, decimals ?? (Number.isInteger(pb) ? 0 : 2))}PB`;
+            return isNegative ? `-${str}` : str;
+        }
+        // EB
+        if (remaining < this.zettabyte) {
+            const eb = remaining / this.exabyte;
+            if (full) {
+                const ebWhole = Math.floor(eb);
+                const remainderAfterEb = remaining - (ebWhole * this.exabyte);
+                const pbRemainder = Math.floor(remainderAfterEb / this.petabyte);
+                const sign = isNegative ? '-' : '';
+                if (pbRemainder > 0) {
+                    return `${sign}${ebWhole}EB ${pbRemainder}PB`;
+                }
+                return `${sign}${ebWhole}EB`;
+            }
+            const str = `${math_util_1.DyFM_Math.round(eb, decimals ?? (Number.isInteger(eb) ? 0 : 2))}EB`;
+            return isNegative ? `-${str}` : str;
+        }
+        // ZB
+        if (remaining < this.yottabyte) {
+            const zb = remaining / this.zettabyte;
+            if (full) {
+                const zbWhole = Math.floor(zb);
+                const remainderAfterZb = remaining - (zbWhole * this.zettabyte);
+                const ebRemainder = Math.floor(remainderAfterZb / this.exabyte);
+                const sign = isNegative ? '-' : '';
+                if (ebRemainder > 0) {
+                    return `${sign}${zbWhole}ZB ${ebRemainder}EB`;
+                }
+                return `${sign}${zbWhole}ZB`;
+            }
+            const str = `${math_util_1.DyFM_Math.round(zb, decimals ?? (Number.isInteger(zb) ? 0 : 2))}ZB`;
+            return isNegative ? `-${str}` : str;
+        }
+        // YB
+        const yb = remaining / this.yottabyte;
+        if (full) {
+            const ybWhole = Math.floor(yb);
+            const remainderAfterYb = remaining - (ybWhole * this.yottabyte);
+            const zbRemainder = Math.floor(remainderAfterYb / this.zettabyte);
+            const sign = isNegative ? '-' : '';
+            if (zbRemainder > 0) {
+                return `${sign}${ybWhole}YB ${zbRemainder}ZB`;
+            }
+            return `${sign}${ybWhole}YB`;
+        }
+        const str = `${math_util_1.DyFM_Math.round(yb, decimals ?? (Number.isInteger(yb) ? 0 : 2))}YB`;
+        return isNegative ? `-${str}` : str;
+    }
+}
+exports.DyFM_Data = DyFM_Data;
 //# sourceMappingURL=data.util.js.map

package/build/_collections/utils/extract-error-message.util.d.ts

@@ -1,71 +1,71 @@
-import { DyFM_AnyError } from '../../_models/control-models/error.control-model';
-/**
- * Options for `DyFM_extractErrorMessage`.
- */
-export interface DyFM_ExtractErrorMessage_Options {
-    /**
-     * Optional prefix prepended to the result with ': '. e.g. `prefix: 'Login'`
-     * → `'Login: <message>'`. Useful for distinguishing the UI surface.
-     */
-    prefix?: string;
-    /**
-     * Fallback string when no usable message can be extracted. Defaults to
-     * a human-readable diagnostic that mentions checking server logs.
-     */
-    fallback?: string;
-    /**
-     * When `true`, the returned string includes HTTP status + statusText after
-     * the main message (in parens) for HTTP errors. Default: `true`.
-     */
-    includeHttpStatus?: boolean;
-}
-/**
- * Universal error → human-readable string extractor. **Never** returns the
- * literal string `'undefined'` (or `'undefined undefined'`), `'[object Object]'`,
- * or any other JS-rendering artifact. Walks the full DyFM_Error pipeline plus
- * common Angular HttpErrorResponse + plain Error shapes, falling back to a
- * meaningful diagnostic string when the input is malformed.
- *
- * Order of attempts (first non-empty wins):
- *   1. `err.__userMessage` (DyFM_Error admin-actionable user message)
- *   2. `err._message` (DyFM_Error aggregated debug message)
- *   3. `err.message` (plain Error.message)
- *   4. `err.userMessage` (deprecated DyFM_Error_Settings field, still seen
- *      on some payloads)
- *   5. `err.error.__userMessage` (HttpErrorResponse wrapping a DyFM_Error in
- *      its body)
- *   6. `err.error._message`
- *   7. `err.error.message`
- *   8. `err.error.userMessage`
- *   9. If `err` itself is a string, use as-is
- *  10. JSON-stringified payload (circular-safe; first 200 chars) as a last
- *      resort, prefixed with 'Malformed error: '
- *  11. `options.fallback` (or its default)
- *
- * When `includeHttpStatus` is true (default) and the input looks like a
- * HttpErrorResponse, the status + statusText are appended in parens: e.g.
- * `'Bad credentials (HTTP 401 Unauthorized)'`.
- *
- * @example
- * ```ts
- * try {
- *   await auth_CS.login(account);
- * } catch (err) {
- *   this.formError = DyFM_extractErrorMessage(err, { prefix: 'Login' });
- *   // → 'Login: Bad credentials (HTTP 401 Unauthorized)'
- *   //   OR
- *   // → 'Login: Network unreachable — check connection. Server logs may have detail.'
- *   //   never 'Login: undefined undefined'
- * }
- * ```
- */
-export declare function DyFM_extractErrorMessage(err: DyFM_AnyError | unknown, options?: DyFM_ExtractErrorMessage_Options): string;
-/**
- * Convenience: same as DyFM_extractErrorMessage but always includes a default
- * prefix derived from the calling context, useful for adding diagnostic
- * breadcrumbs without per-call boilerplate.
- */
-export declare function DyFM_formatError(err: DyFM_AnyError | unknown, prefix: string): string;
-export declare function DyFM_registerMalformedErrorSink(fn: (err: unknown, context?: string) => void): void;
-export declare function DyFM_reportMalformedError(err: unknown, context?: string): void;
+import { DyFM_AnyError } from '../../_models/control-models/error.control-model';
+/**
+ * Options for `DyFM_extractErrorMessage`.
+ */
+export interface DyFM_ExtractErrorMessage_Options {
+    /**
+     * Optional prefix prepended to the result with ': '. e.g. `prefix: 'Login'`
+     * → `'Login: <message>'`. Useful for distinguishing the UI surface.
+     */
+    prefix?: string;
+    /**
+     * Fallback string when no usable message can be extracted. Defaults to
+     * a human-readable diagnostic that mentions checking server logs.
+     */
+    fallback?: string;
+    /**
+     * When `true`, the returned string includes HTTP status + statusText after
+     * the main message (in parens) for HTTP errors. Default: `true`.
+     */
+    includeHttpStatus?: boolean;
+}
+/**
+ * Universal error → human-readable string extractor. **Never** returns the
+ * literal string `'undefined'` (or `'undefined undefined'`), `'[object Object]'`,
+ * or any other JS-rendering artifact. Walks the full DyFM_Error pipeline plus
+ * common Angular HttpErrorResponse + plain Error shapes, falling back to a
+ * meaningful diagnostic string when the input is malformed.
+ *
+ * Order of attempts (first non-empty wins):
+ *   1. `err.__userMessage` (DyFM_Error admin-actionable user message)
+ *   2. `err._message` (DyFM_Error aggregated debug message)
+ *   3. `err.message` (plain Error.message)
+ *   4. `err.userMessage` (deprecated DyFM_Error_Settings field, still seen
+ *      on some payloads)
+ *   5. `err.error.__userMessage` (HttpErrorResponse wrapping a DyFM_Error in
+ *      its body)
+ *   6. `err.error._message`
+ *   7. `err.error.message`
+ *   8. `err.error.userMessage`
+ *   9. If `err` itself is a string, use as-is
+ *  10. JSON-stringified payload (circular-safe; first 200 chars) as a last
+ *      resort, prefixed with 'Malformed error: '
+ *  11. `options.fallback` (or its default)
+ *
+ * When `includeHttpStatus` is true (default) and the input looks like a
+ * HttpErrorResponse, the status + statusText are appended in parens: e.g.
+ * `'Bad credentials (HTTP 401 Unauthorized)'`.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await auth_CS.login(account);
+ * } catch (err) {
+ *   this.formError = DyFM_extractErrorMessage(err, { prefix: 'Login' });
+ *   // → 'Login: Bad credentials (HTTP 401 Unauthorized)'
+ *   //   OR
+ *   // → 'Login: Network unreachable — check connection. Server logs may have detail.'
+ *   //   never 'Login: undefined undefined'
+ * }
+ * ```
+ */
+export declare function DyFM_extractErrorMessage(err: DyFM_AnyError | unknown, options?: DyFM_ExtractErrorMessage_Options): string;
+/**
+ * Convenience: same as DyFM_extractErrorMessage but always includes a default
+ * prefix derived from the calling context, useful for adding diagnostic
+ * breadcrumbs without per-call boilerplate.
+ */
+export declare function DyFM_formatError(err: DyFM_AnyError | unknown, prefix: string): string;
+export declare function DyFM_registerMalformedErrorSink(fn: (err: unknown, context?: string) => void): void;
+export declare function DyFM_reportMalformedError(err: unknown, context?: string): void;
 //# sourceMappingURL=extract-error-message.util.d.ts.map