@futdevpro/fsm-dynamo 1.20.92 → 1.20.94

package/build-esm/_collections/utils/regex/username-regex.util.js

@@ -0,0 +1,28 @@
+export const DyFM_usernameRegex = new RegExp('^[a-zA-Z0-9-_#$%&^|*]{6,}$');
+/* export const FDP_usernameRegexUserMessage: string =
+  'Username must be at least 6 characters long and can only contain letters, ' +
+  'numbers, and the following special characters: -_#$%&^|*'; */
+/* export function getUsernameErrors(username: string): string[] {
+  const errors: string[] = [];
+
+  usernameErrorsOneByOne.forEach((error) => {
+    if (!error.regex.test(username)) {
+      errors.push(error.message);
+    }
+  });
+
+  return errors;
+} */
+const DyFM_usernameErrorsOneByOne = [
+    {
+        regex: new RegExp('^(?=.{6,})'),
+        code: 'usernameErrorLength',
+        /* message: 'Username must be at least 6 characters long.' */
+    },
+    {
+        regex: new RegExp('^(?=.*[a-zA-Z0-9-_#$%&^|*])'),
+        code: 'usernameErrorSpecialChar',
+        /* message:
+          'Username can only contain letters, numbers, and the following special characters: -_#$%&^|*' */
+    },
+];

package/build-esm/_collections/utils/require-env.util.js

@@ -0,0 +1,90 @@
+import { DyFM_Error } from '../../_models/control-models/error.control-model';
+import { DyFM_global_settings } from '../constants/global-settings.const';
+/**
+ * FR-015 Phase 2 — isomorphic env-var requirement helper.
+ *
+ * Universal source of truth for "read this configuration key from an env-var
+ * across Node and browser". Replaces per-package `requireEnv` helpers (the
+ * Phase 1 local implementation in fdp-templates-nts is being refactored to
+ * delegate here).
+ *
+ * Lookup order:
+ *   1. `process.env[envVarName]` — Node-side (server const files at module load).
+ *   2. `DyFM_global_settings.envOverrides[envVarName]` — browser-side, populated
+ *      by the consumer at app bootstrap from its `environment.ts`. See
+ *      DyFM_Global_Settings.envOverrides docs for the pattern.
+ *   3. `options.fallback` if provided — used during migration's additive phase.
+ *   4. throw a structured DyFM_Error with the full deploy-target checklist.
+ *
+ * The throw shape is rich on purpose (per the rich-error rule):
+ *   - `___status` = 500 (configuration error)
+ *   - `_errorCode` = caller-supplied stable code
+ *   - `_message` = debug-level description with the env-var name + deploy-target
+ *     checklist (host .env, docker-compose env-block, Overseer secrets-store,
+ *     client environment.ts → bootstrap envOverrides)
+ *   - `__userMessage` = admin-actionable message
+ *   - `___issuerService` = caller-supplied package short-code
+ *
+ * @example Node server const file (module load):
+ * ```ts
+ * import { DyFM_requireEnv } from '@futdevpro/fsm-dynamo';
+ *
+ * export const FDP_keysEnv_settingsBase = {
+ *   authKey: DyFM_requireEnv('FDP_CORE_FE_AUTH_KEY', {
+ *     errorCode: 'FDP-ENV-MISSING-CORE-FE-AUTH-KEY',
+ *     issuerService: 'fdp-templates',
+ *     fallback: '<inherit literal>',   // remove for Wave 3
+ *   }),
+ * };
+ * ```
+ *
+ * @example Browser-side lazy getter (deferred to first access, after consumer
+ * bootstrap has populated DyFM_global_settings.envOverrides):
+ * ```ts
+ * let _cached: string | undefined;
+ * function _resolveKey(): string {
+ *   if (_cached !== undefined) return _cached;
+ *   _cached = DyFM_requireEnv('DyNM_STORAGE_ENCRYPTION_KEY', { ... });
+ *   return _cached;
+ * }
+ * export const DyNM_global_settings = {
+ *   get storageEncryptionKey(): string { return _resolveKey(); },
+ * };
+ * ```
+ */
+export function DyFM_requireEnv(envVarName, options) {
+    // Node path: process.env at module-load time. Guarded for browser bundles
+    // where `process` may be undefined or shimmed without runtime values.
+    if (typeof process !== 'undefined' && process.env && process.env[envVarName]) {
+        return process.env[envVarName];
+    }
+    // Browser path: consumer-populated envOverrides map. Populated at app
+    // bootstrap from environment.ts — see DyFM_Global_Settings.envOverrides.
+    const override = DyFM_global_settings.envOverrides?.[envVarName];
+    if (override) {
+        return override;
+    }
+    // Transition fallback (Wave 1 of an FR-015-style migration).
+    if (options.fallback !== undefined) {
+        return options.fallback;
+    }
+    // Missing — fail fast with a rich, debug-friendly DyFM_Error.
+    throw new DyFM_Error({
+        status: 500,
+        errorCode: options.errorCode,
+        message: `Environment variable '${envVarName}' is required but was not found. ` +
+            `Checked: process.env.${envVarName} (Node) and ` +
+            `DyFM_global_settings.envOverrides['${envVarName}'] (browser). ` +
+            `Both unset, and no transition fallback configured. ` +
+            `Set '${envVarName}' on every deploy target before deploying this ` +
+            `package version: (1) host .env on every host running a backend, ` +
+            `(2) docker-compose env-block on every consumer service, ` +
+            `(3) Overseer secrets-store entry for CI builds, ` +
+            `(4) client environment.ts plus app-bootstrap copy into ` +
+            `DyFM_global_settings.envOverrides for any browser consumer.`,
+        userMessage: options.userMessage
+            ?? `Configuration error — environment variable '${envVarName}' is missing. `
+                + `Contact the responsible operator to set it on this deploy target.`,
+        issuerService: options.issuerService,
+    });
+}

package/build-esm/_collections/utils/round-list.util.js

@@ -0,0 +1,108 @@
+/**
+ * This class is a collection of static methods for round list operations
+ * A round list is a list that is circular
+ * - after the last element, the first comes next
+ */
+export class DyFM_RoundList {
+    /**
+     * returns the outbound index of the list
+     * @param listLength
+     * @param outboundIndex
+     * @returns
+     *
+     * @example
+     * ```ts
+     * const listLength = 10;
+     * const outboundIndex = 15;
+     * const result = DyFM_RoundList.getOutboundedIndex(listLength, outboundIndex);
+     * console.log(result); // 5
+     * ```
+     */
+    static getOutboundedIndex(listLength, outboundIndex) {
+        if (!listLength) {
+            throw new Error('roundListPlusIndex failed. list is empty!');
+        }
+        if (outboundIndex < 0) {
+            outboundIndex = outboundIndex % listLength;
+            outboundIndex = listLength + outboundIndex;
+        }
+        if (listLength <= outboundIndex) {
+            outboundIndex = outboundIndex % listLength;
+        }
+        return outboundIndex;
+    }
+    /**
+     * returns the index of the opposite element of the list
+     * - as they are circular, the opposite is at the half of the list
+     * - as it is circular, for the second half, the opposite is at the first half
+     * @param length
+     * @param oppositeOf
+     * @returns
+     *
+     * @example
+     * ```ts
+     * const length = 10;
+     * const oppositeOf = 5;
+     * const result = DyFM_RoundList.getIndexOpposite(length, oppositeOf);
+     * console.log(result); // 0
+     * ```
+     */
+    static getIndexOpposite(length, oppositeOf) {
+        const plusIndex = oppositeOf + Math.round(length / 2);
+        const res = this.getOutboundedIndex(length, plusIndex);
+        return res;
+    }
+    /**
+     * returns the element at the outbound index of the list
+     * @param list
+     * @param outboundIndex
+     * @returns
+     *
+     * @example
+     * ```ts
+     * const list = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
+     * const outboundIndex = 15;
+     * const result = DyFM_RoundList.getListIndex(list, outboundIndex);
+     * console.log(result); // 5
+     * ```
+     */
+    static getListIndex(list, outboundIndex) {
+        return list[this.getOutboundedIndex(list.length, outboundIndex)];
+    }
+    /**
+     * returns the element at the opposite index of the list
+     * @param list
+     * @param oppositeOf
+     * @returns
+     *
+     * @example
+     * ```ts
+     * const list = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
+     * const oppositeOf = 5;
+     * const result = DyFM_RoundList.getListOpposite(list, oppositeOf);
+     * console.log(result); // 0
+     * ```
+     */
+    static getListOpposite(list, oppositeOf) {
+        return list[this.getIndexOpposite(list.length, list.indexOf(oppositeOf))];
+    }
+    /**
+     * returns the last element of the list
+     * returns null if the list is empty
+     *
+     * @example
+     * ```ts
+     * const list = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
+     * const result = DyFM_RoundList.getLast(list);
+     * console.log(result); // 10
+     * ```
+     */
+    static getLast(list) {
+        if (0 < list.length) {
+            return list[list.length - 1];
+        }
+        else {
+            return null;
+        }
+    }
+}

package/build-esm/_collections/utils/secret-mask.util.js

@@ -0,0 +1,219 @@
+// publish-check-allow-file — EZ a titok-maszkolo detektor-definicioja: a mintak es a
+// magyarazo peldak (`mongodb://user:pass@host`) a funkcio reszei, nem beegetett titkok.
+/**
+ * FR-093 (2026-06-09) — Universal secret/key masking utility (bedrock level).
+ *
+ * Lehetove teszi az ALL-FDP-systems-szintu secret-szivargas-detection +
+ * maszkolas-t egy bedrock-szinten. A korabban Overseer / runner-worker
+ * helyi util-jai (FR-092) most ezt importaljak — egy SOR konfiguracio +
+ * find-and-replace.
+ *
+ * User feedback ('az osszes rendszerunknek a lenyege az univerzalizalt,
+ * mindenhol hasznalhato, egysegesített megoldások'): every secret-pattern
+ * ennek a egyetlen DyFM_SecretMask_Util-nak a felelossege.
+ *
+ * Strategy — KETTOS:
+ *   1. **PATTERN-based**: ismert secret-formatumokra automatikus felismeres.
+ *   2. **VALUE-based**: a process.env-jenek secret-erteket overlay-eli minden szovegben.
+ *
+ * Identifiability config (`DyFM_SecretMask_Settings.partialReveal`):
+ *   - DEFAULT: `{ prefix: 4, suffix: 4 }` — a kulcsok elso 4 + utolso 4 char-ja
+ *     megorzodik, kozeppe `[redacted-<KIND>]` keruln, pl.:
+ *       `ghp_abcdefghij1234567890abcdefghij12345678` → `ghp_abcd...5678 [redacted-github-pat]`
+ *   - User-extensible: csokkentett vagy 0-os reveal a tobb-biztonsagos
+ *     deploymentekhez (`{ prefix: 0, suffix: 0 }` → tisztan opaque).
+ *
+ * Per memory `[[feedback_rich_error_handling]]`: a maszkolt token jelzes ne
+ * legyen `***` opaque; legyen `[redacted-<KIND>]` hogy ranezessel lassuk MILYEN
+ * tipusu szivargast szuntunk meg.
+ *
+ * Pattern-mapping per memory `[[feedback_individual_plans]]` — single source of
+ * truth: minden uj secret-format hozzaadando a `DyFM_SECRET_PATTERNS` array-hez;
+ * a tobbi rendszerben (Overseer/runner/bedrock packages) automatikusan
+ * megjelenik a fsm-bump utan.
+ */
+export const DyFM_DEFAULT_SECRET_MASK_SETTINGS = {
+    partialReveal: {
+        prefix: 4,
+        suffix: 4,
+    },
+    minEnvValueLength: 8,
+    envNameSecretRx: /(?:TOKEN|SECRET|KEY|PASSWORD|PASSWD|PAT|HMAC|AUTH|PRIVATE|CREDENTIAL|API_KEY|WEBHOOK)/i,
+};
+const defaultRevealReplacement = (matched, kind, settings) => {
+    const p = Math.max(0, settings.partialReveal.prefix);
+    const s = Math.max(0, settings.partialReveal.suffix);
+    // Ha a kulcs tul rovid az osszes reveal-osszeghez kepest, ne reveal-juk
+    // (kulonben az egesz secret elerhetonek osszetapadna).
+    if (matched.length <= p + s + 4) {
+        return `[redacted-${kind}]`;
+    }
+    if (p === 0 && s === 0) {
+        return `[redacted-${kind}]`;
+    }
+    const head = matched.slice(0, p);
+    const tail = matched.slice(matched.length - s);
+    return `${head}...${tail} [redacted-${kind}]`;
+};
+export const DyFM_SECRET_PATTERNS = [
+    // URL-embedded basic auth — BARMELY scheme (`http(s)`, `mongodb`, `postgres`, `redis`,
+    // `amqp`, `mysql` stb.), nem csak http: a `mongodb://user:pass@host` connection-string a
+    // leggyakoribb DB-secret-leak vektor a CI-logokban. A `user:pass@` szerkezet kotelezo →
+    // nincs false-positive a sima URL-ekre (port `host:8080/` sem, mert nincs utana `@`).
+    // A sajat replace-pattern megorzi a scheme-et ($1) + host-ot.
+    {
+        kind: 'url-cred',
+        regex: /\b([a-z][a-z0-9+.-]*:\/\/)([^/\s:@]*):([^\s@]+)@/gi,
+        redactWith: (_m) => '$1[redacted-url-cred]@',
+    },
+    // GitHub PATs
+    { kind: 'github-pat', regex: /\bgh[ps]_[A-Za-z0-9]{36,}\b/g },
+    { kind: 'github-pat-fine', regex: /\bgithub_pat_[A-Za-z0-9_]{82,}\b/g },
+    { kind: 'github-oauth', regex: /\bgho_[A-Za-z0-9]{36,}\b/g },
+    { kind: 'github-refresh', regex: /\bghr_[A-Za-z0-9]{36,}\b/g },
+    // NPM token
+    { kind: 'npm-token', regex: /\bnpm_[A-Za-z0-9]{36,}\b/g },
+    // Docker Hub PAT
+    { kind: 'docker-pat', regex: /\bdckr_pat_[A-Za-z0-9_\-]{20,}\b/g },
+    // Slack token
+    { kind: 'slack-token', regex: /\bxox[abprs]-[A-Za-z0-9-]{10,}\b/g },
+    // Anthropic key (BEFORE OpenAI — `sk-ant-*` more specific than `sk-*`)
+    { kind: 'anthropic-key', regex: /\bsk-ant-[A-Za-z0-9\-_]{32,}\b/g },
+    // OpenAI / generic `sk-*` key
+    { kind: 'openai-key', regex: /\bsk-[A-Za-z0-9]{32,}\b/g },
+    // Google API key
+    { kind: 'google-api-key', regex: /\bAIza[0-9A-Za-z\-_]{35}\b/g },
+    // Discord webhook URL (id + token in URL)
+    {
+        kind: 'discord-webhook',
+        regex: /\bhttps?:\/\/(?:discord(?:app)?\.com|discordapp\.com)\/api\/webhooks\/\d+\/[A-Za-z0-9_\-]+/g,
+        redactWith: (_m) => '[redacted-discord-webhook]',
+    },
+    // Bearer token in HTTP header style — megorizzuk a 'Bearer ' prefixet (literally), a token-t pedig reveal-eljuk.
+    {
+        kind: 'bearer-token',
+        regex: /\b(Bearer)\s+([A-Za-z0-9\-._~+/=]{20,})/gi,
+        redactWith: (matched, settings) => {
+            const tokenStart = matched.search(/\s+/);
+            const prefix = matched.slice(0, tokenStart + 1); // 'Bearer '
+            const token = matched.slice(tokenStart + 1);
+            return prefix + defaultRevealReplacement(token, 'token', settings);
+        },
+    },
+    // JWT (eyJ + .* + .*)
+    { kind: 'jwt', regex: /\beyJ[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\b/g },
+    // AWS Access Key
+    { kind: 'aws-access-key', regex: /\bAKIA[0-9A-Z]{16}\b/g },
+    // Env-style secret-name = value
+    {
+        kind: 'env-style-secret',
+        regex: /\b([A-Z][A-Z0-9_]*(?:TOKEN|SECRET|KEY|PASSWORD|PASSWD|PAT|HMAC|AUTH|PRIVATE)[A-Z0-9_]*)\s*[:=]\s*['"]?([^\s'"]+)['"]?/g,
+        redactWith: (matched, settings) => {
+            // Pull out the key name + value via re-match (avoids capturing groups in redactWith signature)
+            const m = matched.match(/\b([A-Z][A-Z0-9_]*(?:TOKEN|SECRET|KEY|PASSWORD|PASSWD|PAT|HMAC|AUTH|PRIVATE)[A-Z0-9_]*)\s*[:=]\s*['"]?([^\s'"]+)/);
+            if (!m) {
+                return matched;
+            }
+            const keyName = m[1];
+            const value = m[2];
+            const sep = matched.includes(': ') ? '=' : '=';
+            const revealed = defaultRevealReplacement(value, 'env-value', settings);
+            return `${keyName}${sep}${revealed}`;
+        },
+    },
+];
+/**
+ * `process.env`-bol kigyujti azokat a kulcsokat ahol a NEV titkos-jellegu
+ * ÉS a value >= minEnvValueLength. Visszaad egy listat — ezeket szovegben
+ * minden elofordulasban partial-reveal-el felulrak-juk.
+ */
+const collectEnvSecretValues = (settings) => {
+    const out = [];
+    for (const [key, raw] of Object.entries(process.env)) {
+        if (!raw || raw.length < settings.minEnvValueLength) {
+            continue;
+        }
+        if (!settings.envNameSecretRx.test(key)) {
+            continue;
+        }
+        if (/^(true|false|0|1)$/i.test(raw)) {
+            continue;
+        }
+        out.push({ value: raw, key: key });
+    }
+    // Sort by value length DESC — hosszabb ertekekkel kezdjuk, igy egy rovid
+    // prefix nem sealeze el a hosszabb kornyezetet.
+    out.sort((a, b) => b.value.length - a.value.length);
+    return out;
+};
+/**
+ * `DyFM_maskSecrets` — universal pre-Discord-send + pre-log-persist masking.
+ *
+ * @param text bemenet (ha nem string, JSON-szerializalaskor maskoljuk)
+ * @param settings  konfiguracio (default a DyFM_DEFAULT_SECRET_MASK_SETTINGS)
+ * @returns maszkolt szoveg
+ */
+export function DyFM_maskSecrets(text, settings = DyFM_DEFAULT_SECRET_MASK_SETTINGS) {
+    if (text === null || text === undefined) {
+        return '';
+    }
+    let str;
+    if (typeof text === 'string') {
+        str = text;
+    }
+    else {
+        try {
+            str = JSON.stringify(text);
+        }
+        catch {
+            str = String(text);
+        }
+    }
+    // 1. PATTERN-based maszkolas
+    for (const p of DyFM_SECRET_PATTERNS) {
+        str = str.replace(p.regex, (matched, ...groups) => {
+            // Drop the `offset` + `wholeString` args at the end of `groups`
+            if (p.redactWith) {
+                return p.redactWith(matched, settings)
+                    .replace(/\$1/g, groups[0] ?? '')
+                    .replace(/\$2/g, groups[1] ?? '');
+            }
+            // Default: partial-reveal with kind
+            return defaultRevealReplacement(matched, p.kind, settings);
+        });
+    }
+    // 2. ENV-secret value-alapu overlay
+    const envSecrets = collectEnvSecretValues(settings);
+    for (const { value, key } of envSecrets) {
+        if (!str.includes(value)) {
+            continue;
+        }
+        const revealed = defaultRevealReplacement(value, `env-${key}`, settings);
+        str = str.split(value).join(revealed);
+    }
+    return str;
+}
+/**
+ * Recursive object-masker — JSON-szeru struktura minden string-ertekeben alkalmazza
+ * a DyFM_maskSecrets-t. Pl. errors-table additionalContent / logTail tomb / cdpReport
+ * objektum elotti masking-hez.
+ */
+export function DyFM_maskSecretsDeep(input, settings = DyFM_DEFAULT_SECRET_MASK_SETTINGS) {
+    if (input === null || input === undefined) {
+        return input;
+    }
+    if (typeof input === 'string') {
+        return DyFM_maskSecrets(input, settings);
+    }
+    if (typeof input !== 'object') {
+        return input;
+    }
+    if (Array.isArray(input)) {
+        return input.map((it) => DyFM_maskSecretsDeep(it, settings));
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(input)) {
+        out[k] = DyFM_maskSecretsDeep(v, settings);
+    }
+    return out;
+}

package/build-esm/_collections/utils/stack.util.js

@@ -0,0 +1,126 @@
+import { DyFM_Log } from './log.util';
+/**
+ * Get the stack location of the constructor call
+ * use it in the constructor of a class to get the stack location of the constructor call
+ * @param level - The level of the stack to get the location of
+ * @returns The stack location of the constructor call
+ *
+ * @example
+ * ```ts
+ * const stackLocation = DyFM_getConstructionStackLocation();
+ * console.log(stackLocation); // The stack location of the constructor call
+ * ```
+ */
+export function DyFM_getConstructionStackLocation(level = 0) {
+    const stack = new Error().stack;
+    // Split the stack into lines and remove the first line (Error:)
+    let stackLines = stack?.split('\n')?.slice(2);
+    // Find the line that contains the constructor call
+    // It will be the FIRST line that doesn't contain 'getStackLocation'
+    let constructorLine = stackLines?.find(line => line &&
+        !line.includes('getStackLocation') &&
+        !line.includes('new') &&
+        !line.includes('node_modules') &&
+        !line.includes('node:'));
+    if (isNaN(level)) {
+        throw new Error('level must be a number');
+    }
+    if (level) {
+        while (level) {
+            stackLines = stackLines?.filter(line => line !== constructorLine);
+            level--;
+            constructorLine = stackLines?.find(line => line &&
+                !line.includes('getConstructionStackLocation') &&
+                !line.includes('new') &&
+                !line.includes('node_modules') &&
+                !line.includes('node:'));
+        }
+    }
+    if (!constructorLine) {
+        constructorLine = stack?.split(' at ')?.find(line => line &&
+            !line.includes('getConstructionStackLocation') &&
+            !line.includes('new') &&
+            !line.includes('node_modules') &&
+            !line.includes('node:'));
+        if (!constructorLine) {
+            DyFM_Log.warn(`No constructor line found (0)\n${typeof stack}\n${stack?.slice(0, 300)?.split('\n') + '...'}`, {
+                stack,
+            });
+            return '';
+        }
+    }
+    // Remove the 'constructorLine     at ... (' and the ')'
+    if (constructorLine?.includes('(')) {
+        constructorLine = constructorLine?.split('(')[1];
+    }
+    if (constructorLine?.includes(')')) {
+        constructorLine = constructorLine?.split(')')[0];
+    }
+    if (!constructorLine) {
+        DyFM_Log.warn(`No constructor line found (1)\n${typeof stack}\n${stack?.slice(0, 300)?.split('\n') + '...'}`, {
+            stack,
+        });
+        return '';
+    }
+    return constructorLine;
+}
+/**
+ * Get the stack location of the local call
+ * use it in the local function to get the stack location of the local call
+ * @param level - The level of the stack to get the location of
+ * @returns The stack location of the local call
+ *
+ * @example
+ * ```ts
+ * const stackLocation = DyFM_getLocalStackLocation(1);
+ * console.log(stackLocation); // The stack location of the local call
+ * ```
+ */
+export function DyFM_getLocalStackLocation(level = 0) {
+    let stack = new Error().stack;
+    // Split the stack into lines and remove the first line (Error:) and the second line (DyFM_getLocalStackLocation)
+    let stackLines = stack?.split('\n')?.slice(2);
+    // Find the line that contains the location
+    // It will be the FIRST line that doesn't contain 'node_modules' or 'node:'
+    let locationLine = stackLines?.find(line => line &&
+        !line.includes('node_modules') &&
+        !line.includes('node:'));
+    if (isNaN(level)) {
+        throw new Error('level must be a number');
+    }
+    if (level) {
+        while (level) {
+            stackLines = stackLines?.filter(line => line !== locationLine);
+            level--;
+            locationLine = stackLines?.find(line => line &&
+                !line.includes('node_modules') &&
+                !line.includes('node:'));
+        }
+    }
+    if (!locationLine) {
+        locationLine = stack?.split(' at ')?.find(line => line &&
+            !line.includes('node_modules') &&
+            !line.includes('node:'));
+        if (!locationLine) {
+            DyFM_Log.warn(`No location line found outside of node_modules or node: (0)` +
+                `\n${typeof stack}\n${stack?.slice(0, 300)?.split('\n') + '...'}`, {
+                stack,
+            });
+            return '';
+        }
+    }
+    // Remove the 'constructorLine     at ... (' and the ')'
+    if (locationLine?.includes('(')) {
+        locationLine = locationLine?.split('(')[1];
+    }
+    if (locationLine?.includes(')')) {
+        locationLine = locationLine?.split(')')[0];
+    }
+    if (!locationLine) {
+        DyFM_Log.warn(`No location line found (1)\n${typeof stack}\n${stack?.slice(0, 300)?.split('\n') + '...'}`, {
+            stack,
+        });
+        return '';
+    }
+    return locationLine;
+}