@ingcrea/aumic-sanitizer 0.0.0-stage → 5.4.2

package/dist/2-molecules/MojibakeEngine.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MojibakeEngine = void 0;
+const mojibake_vectors_1 = require("../1-atoms/mojibake-vectors");
+class MojibakeEngine {
+    /**
+     * Motor Heurístico de Sanitización de Nivel 7.
+     * Evalúa la presencia de firmas de corrupción antes de disparar mutaciones.
+     */
+    static cure(raw, allowedVectors) {
+        let fixed = raw;
+        let totalCount = 0;
+        const scores = {
+            LATIN1: 0,
+            CP1252_PUNCTUATION: 0,
+            HTML_ENTITIES: 0,
+            DOUBLE_UTF8: 0
+        };
+        // 1. Barrido Forense (Scoring)
+        for (const vector of allowedVectors) {
+            const dict = mojibake_vectors_1.VECTORS[vector];
+            for (const bad of Object.keys(dict)) {
+                const count = fixed.split(bad).length - 1;
+                if (count > 0)
+                    scores[vector] += count;
+            }
+        }
+        // 2. Ejecución Jerárquica (Para evitar colisiones entre encodings anidados)
+        const hierarchy = [
+            'DOUBLE_UTF8', // Jerarquía Máxima (Contiene LATIN1 anidado)
+            'HTML_ENTITIES', // Jerarquía Alta (Sintaxis explícita)
+            'LATIN1', // Jerarquía Media (Mapeo directo)
+            'CP1252_PUNCTUATION' // Jerarquía Estándar
+        ];
+        for (const vector of hierarchy) {
+            if (allowedVectors.includes(vector) && scores[vector] > 0) {
+                const { res, c } = this.applyVector(fixed, vector);
+                fixed = res;
+                totalCount += c;
+            }
+        }
+        return { fixed, count: totalCount };
+    }
+    static applyVector(raw, vector) {
+        let res = raw;
+        let c = 0;
+        for (const [bad, good] of Object.entries(mojibake_vectors_1.VECTORS[vector])) {
+            const count = res.split(bad).length - 1;
+            if (count > 0) {
+                res = res.replaceAll(bad, good);
+                c += count;
+            }
+        }
+        return { res, c };
+    }
+}
+exports.MojibakeEngine = MojibakeEngine;

package/dist/2-molecules/config.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = void 0;
+exports.loadConfig = loadConfig;
+exports.initConfig = initConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.DEFAULT_CONFIG = {
+    gitMode: 'block',
+    rules: {
+        mojibake: true,
+        emojis: true,
+        crlf: true,
+        smartQuotes: true,
+        zeroWidth: true,
+        eradicator: false
+    }
+};
+function loadConfig(targetDir) {
+    const configPath = path_1.default.join(targetDir, 'aumic.config.json');
+    if (fs_1.default.existsSync(configPath)) {
+        try {
+            const parsed = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+            return {
+                gitMode: parsed.gitMode || exports.DEFAULT_CONFIG.gitMode,
+                rules: { ...exports.DEFAULT_CONFIG.rules, ...(parsed.rules || {}) }
+            };
+        }
+        catch {
+            return exports.DEFAULT_CONFIG;
+        }
+    }
+    return exports.DEFAULT_CONFIG;
+}
+function initConfig(targetDir) {
+    const configPath = path_1.default.join(targetDir, 'aumic.config.json');
+    fs_1.default.writeFileSync(configPath, JSON.stringify(exports.DEFAULT_CONFIG, null, 4), 'utf8');
+}

package/dist/2-molecules/scanner.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTargetFiles = getTargetFiles;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+function getTargetFiles(targetDir, deltaOnly = false) {
+    const fsLib = require('fs');
+    if (!fsLib.existsSync(targetDir))
+        return [];
+    if (fsLib.statSync(targetDir).isFile()) {
+        return [path_1.default.resolve(targetDir)];
+    }
+    targetDir = path_1.default.resolve(targetDir);
+    const extensions = ['md', 'js', 'ts', 'jsx', 'tsx', 'json', 'yml', 'yaml', 'html', 'css', 'scss', 'astro'];
+    const extGlob = `**/*.{${extensions.join(',')}}`;
+    const rulesGlob = '**/*rules';
+    try {
+        // Si estamos en un repo Git, respetamos el .gitignore de forma estricta
+        (0, child_process_1.execSync)('git rev-parse --is-inside-work-tree', { cwd: targetDir, stdio: 'ignore' });
+        let tracked = [];
+        let untracked = [];
+        if (deltaOnly) {
+            try {
+                tracked = (0, child_process_1.execSync)('git diff --name-only HEAD', { cwd: targetDir, encoding: 'utf-8' }).split('\n').filter(Boolean);
+            }
+            catch (e) {
+                tracked = (0, child_process_1.execSync)('git ls-files', { cwd: targetDir, encoding: 'utf-8' }).split('\n').filter(Boolean);
+            }
+        }
+        else {
+            tracked = (0, child_process_1.execSync)('git ls-files', { cwd: targetDir, encoding: 'utf-8' }).split('\n').filter(Boolean);
+        }
+        untracked = (0, child_process_1.execSync)('git ls-files --others --exclude-standard', { cwd: targetDir, encoding: 'utf-8' }).split('\n').filter(Boolean);
+        const allFiles = [...tracked, ...untracked];
+        return allFiles
+            .filter(f => extensions.some(ext => f.endsWith('.' + ext)) || f.endsWith('rules') || path_1.default.basename(f).startsWith('LICENSE'))
+            .map(f => path_1.default.join(targetDir, f));
+    }
+    catch (e) {
+        // Fallback: fast-glob puro ignorando node_modules
+        return fast_glob_1.default.sync([extGlob, rulesGlob, '**/LICENSE*'], {
+            cwd: targetDir,
+            ignore: ['**/node_modules/**', '**/dist/**', '**.git/**'],
+            absolute: true
+        });
+    }
+}

package/dist/3-cells/HookManager.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installGitHook = installGitHook;
+exports.installGlobalGitHook = installGlobalGitHook;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const child_process_1 = require("child_process");
+const HOOK_SCRIPT_LOCAL = '#!/usr/bin/env bash\n# AUM-IC Self-Healing Hook\n\naumic-sanitizer scan --from-hook --delta\nexit $?\n';
+// Hook Global Inteligente (Corre AUM-IC y luego encadena con Husky/Lefthook si existen)
+const HOOK_SCRIPT_GLOBAL = `#!/usr/bin/env bash
+# AUM-IC Sentinel (Global)
+
+aumic-sanitizer scan --from-hook --delta
+AUM_EXIT=$?
+if [ $AUM_EXIT -ne 0 ]; then
+  exit $AUM_EXIT
+fi
+
+# Delegar a hook local si existe (Respetar Husky / Lefthook)
+if [ -x ".git/hooks/pre-commit" ]; then
+  .git/hooks/pre-commit "$@"
+  exit $?
+fi
+`;
+// ─── Hook LOCAL ─────────────────────────────────────────────────────────────
+function installGitHook(targetDir) {
+    const gitDir = path_1.default.join(targetDir, '.git');
+    if (!fs_1.default.existsSync(gitDir)) {
+        console.log(picocolors_1.default.red('[!] No se detectó un repositorio Git (.git) en esta ruta.'));
+        return;
+    }
+    const hooksDir = path_1.default.join(gitDir, 'hooks');
+    if (!fs_1.default.existsSync(hooksDir))
+        fs_1.default.mkdirSync(hooksDir, { recursive: true });
+    const hookFilePath = path_1.default.join(hooksDir, 'pre-commit');
+    fs_1.default.writeFileSync(hookFilePath, HOOK_SCRIPT_LOCAL, { encoding: 'utf8', mode: 0o755 });
+    console.log(picocolors_1.default.green('✔ Hook pre-commit LOCAL instalado exitosamente.'));
+    console.log(picocolors_1.default.cyan('  Ámbito: Solo este repositorio → ' + targetDir));
+}
+// ─── Hook GLOBAL (Verdadero: core.hooksPath) ──────────────────────────────────
+function installGlobalGitHook() {
+    const globalHooksDir = path_1.default.join(os_1.default.homedir(), '.aumic-hooks');
+    fs_1.default.mkdirSync(globalHooksDir, { recursive: true });
+    const hookFilePath = path_1.default.join(globalHooksDir, 'pre-commit');
+    fs_1.default.writeFileSync(hookFilePath, HOOK_SCRIPT_GLOBAL, { encoding: 'utf8', mode: 0o755 });
+    try {
+        (0, child_process_1.execSync)(`git config --global core.hooksPath "${globalHooksDir}"`, { encoding: 'utf8' });
+        console.log(picocolors_1.default.green('✔ Hook pre-commit GLOBAL Absoluto instalado exitosamente.'));
+        console.log(picocolors_1.default.cyan('  Ruta central: ' + globalHooksDir));
+        console.log(picocolors_1.default.magenta('  ¡Atención! AUM-IC interceptará absolutamente todos los commits'));
+        console.log(picocolors_1.default.magenta('  en esta computadora de ahora en adelante (sin necesidad de init).'));
+        console.log(picocolors_1.default.gray('  (El diseño es seguro: no romperá repositorios que usen Husky).'));
+    }
+    catch (e) {
+        console.log(picocolors_1.default.red('[!] Error configurando core.hooksPath global.'));
+    }
+    // ─── Auto-Gitignore Global ───
+    try {
+        let globalIgnorePath = '';
+        try {
+            globalIgnorePath = (0, child_process_1.execSync)('git config --global core.excludesfile', { encoding: 'utf8' }).trim();
+        }
+        catch (_) { } // Aún no existe la configuración
+        if (!globalIgnorePath) {
+            globalIgnorePath = path_1.default.join(os_1.default.homedir(), '.gitignore_global');
+            (0, child_process_1.execSync)(`git config --global core.excludesfile "${globalIgnorePath}"`, { encoding: 'utf8' });
+        }
+        else if (globalIgnorePath.startsWith('~')) {
+            globalIgnorePath = globalIgnorePath.replace(/^~/, os_1.default.homedir());
+        }
+        if (fs_1.default.existsSync(globalIgnorePath)) {
+            const current = fs_1.default.readFileSync(globalIgnorePath, 'utf8');
+            if (!current.includes('aumic-history.json')) {
+                fs_1.default.appendFileSync(globalIgnorePath, '\n# AUM-IC Forensic Log\naumic-history.json\n', 'utf8');
+            }
+        }
+        else {
+            fs_1.default.writeFileSync(globalIgnorePath, '# AUM-IC Forensic Log\naumic-history.json\n', 'utf8');
+        }
+        console.log(picocolors_1.default.green('✔ AUM-IC adherido al .gitignore global del sistema.'));
+    }
+    catch (e) {
+        console.log(picocolors_1.default.yellow('⚠ No se pudo configurar el .gitignore global automáticamente.'));
+    }
+}

package/dist/3-cells/Sanitizer.js

@@ -0,0 +1,364 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFile = processFile;
+const promises_1 = __importDefault(require("fs/promises"));
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const parser_1 = require("@babel/parser");
+const traverse = require('@babel/traverse').default || require('@babel/traverse');
+const magic_string_1 = __importDefault(require("magic-string"));
+const constants_1 = require("../1-atoms/constants");
+const MojibakeEngine_1 = require("../2-molecules/MojibakeEngine");
+const LanguageProfiler_1 = require("../2-molecules/LanguageProfiler");
+// ─────────────────────────────────────────────────────────────────────────────
+// KERNEL DE REGLAS DE ENTROPIA
+// Recibe un fragmento de texto YA AISLADO y aplica las transformaciones.
+// El modo de smart quotes se decide fuera de esta funcion por el perfil.
+// ─────────────────────────────────────────────────────────────────────────────
+function applyEntropyRules(raw, rules, profile, insideString = false // true = llamado desde un nodo AST o string-regex
+) {
+    let fixed = raw;
+    let count = 0;
+    if (rules.mojibake && profile.allowMojibake) {
+        const { fixed: f, count: c } = MojibakeEngine_1.MojibakeEngine.cure(fixed, profile.allowedMojibakeVectors);
+        if (c > 0) {
+            fixed = f;
+            count += c;
+        }
+    }
+    if (rules.emojis) {
+        fixed = fixed.replace(constants_1.EMOJI_PATTERN, (match) => {
+            const r = (0, constants_1.reverseEmojiMojibake)(match);
+            if (r !== match) {
+                count++;
+                return r;
+            }
+            return match;
+        });
+    }
+    if (rules.smartQuotes) {
+        const mode = profile.smartQuoteMode;
+        const canTouch = mode === 'global' || (insideString && (mode === 'ast-only' || mode === 'string-regex'));
+        if (canTouch) {
+            // Comillas dobles tipograficas — siempre seguras en cualquier contexto
+            const dq = (fixed.match(/[\u201C\u201D]/g) || []).length;
+            if (dq > 0) {
+                fixed = fixed.replace(/[\u201C\u201D]/g, '\x22');
+                count += dq;
+            }
+            // Comillas simples / apostrofes — SOLO si estamos dentro de un string aislado
+            // o en modo global (archivos planos donde no hay delimitadores de lenguaje)
+            if (insideString || mode === 'global') {
+                const sq = (fixed.match(/[\u2018\u2019]/g) || []).length;
+                if (sq > 0) {
+                    fixed = fixed.replace(/[\u2018\u2019]/g, '\x27');
+                    count += sq;
+                }
+            }
+        }
+    }
+    if (rules.zeroWidth && profile.allowZeroWidth) {
+        const inv = /[\u200B\u200C\u200D\u202A-\u202E\u2066-\u2069]/g;
+        const c = (fixed.match(inv) || []).length;
+        if (c > 0) {
+            fixed = fixed.replace(inv, '');
+            count += c;
+        }
+    }
+    return { fixed, count };
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// PROCESADOR AST (JS / TS)
+// Usa Babel para parsear el arbol sintactico y operar SOLO sobre nodos
+// de tipo StringLiteral, TemplateLiteral.quasis y Comment.
+// ─────────────────────────────────────────────────────────────────────────────
+async function processWithAST(filepath, content, rules, profile, audit, gitStage) {
+    let corruptions = 0;
+    try {
+        const ms = new magic_string_1.default(content);
+        const ast = (0, parser_1.parse)(content, {
+            sourceType: 'unambiguous',
+            errorRecovery: true,
+            plugins: ['jsx', 'typescript', 'decorators-legacy', 'classProperties'],
+        });
+        traverse(ast, {
+            StringLiteral({ node }) {
+                const inner = content.slice(node.start + 1, node.end - 1);
+                const { fixed, count } = applyEntropyRules(inner, rules, profile, true);
+                if (count > 0 && fixed !== inner) {
+                    ms.overwrite(node.start + 1, node.end - 1, fixed);
+                    corruptions += count;
+                }
+            },
+            TemplateLiteral({ node }) {
+                for (const quasi of node.quasis) {
+                    const raw = quasi.value.raw;
+                    const { fixed, count } = applyEntropyRules(raw, rules, profile, true);
+                    if (count > 0 && fixed !== raw) {
+                        const s = quasi.start + 1;
+                        const e = quasi.end - 1;
+                        if (s < e) {
+                            ms.overwrite(s, e, fixed);
+                            corruptions += count;
+                        }
+                    }
+                }
+            },
+        });
+        // Comentarios (en ast.comments, fuera del traversal estandar)
+        for (const comment of (ast.comments || [])) {
+            const raw = comment.value;
+            const { fixed, count } = applyEntropyRules(raw, rules, profile, true);
+            if (count > 0 && fixed !== raw) {
+                const s = comment.start + 2;
+                const e = comment.end - (comment.type === 'CommentBlock' ? 2 : 0);
+                if (s < e) {
+                    ms.overwrite(s, e, fixed);
+                    corruptions += count;
+                }
+            }
+        }
+        // Eradicador (solo si el perfil lo permite)
+        let finalContent = ms.toString();
+        if (rules.eradicator && profile.allowEradicator) {
+            const consoleRx = /^[ \t]*console\.(log|info|debug|warn)\(.*?\);?[ \t]*\r?\n?/gm;
+            const debugRx = /^[ \t]*debugger;[ \t]*\r?\n?/gm;
+            const todoRx = /^[ \t]*\/\/ ?TODO:.*?\r?\n?/gmi;
+            const cc = (finalContent.match(consoleRx) || []).length;
+            if (cc > 0) {
+                finalContent = finalContent.replace(consoleRx, '');
+                corruptions += cc;
+            }
+            const dc = (finalContent.match(debugRx) || []).length;
+            if (dc > 0) {
+                finalContent = finalContent.replace(debugRx, '');
+                corruptions += dc;
+            }
+            const tc = (finalContent.match(todoRx) || []).length;
+            if (tc > 0) {
+                finalContent = finalContent.replace(todoRx, '');
+                corruptions += tc;
+            }
+        }
+        // CRLF (nivel de archivo, no de nodo)
+        if (rules.crlf && profile.allowCRLF) {
+            const c = (finalContent.match(/\r\n/g) || []).length;
+            if (c > 0) {
+                finalContent = finalContent.replace(/\r\n/g, '\n');
+                corruptions += c;
+            }
+        }
+        if (corruptions > 0) {
+            if (!audit) {
+                await promises_1.default.writeFile(filepath, finalContent, 'utf8');
+                if (gitStage) {
+                    try {
+                        (0, child_process_1.execSync)(`git add "${filepath}"`, { cwd: path_1.default.dirname(filepath), stdio: 'ignore' });
+                    }
+                    catch (_) { }
+                }
+            }
+            return { filepath, corruptions, modified: true, originalContent: content };
+        }
+        return { filepath, corruptions: 0, modified: false };
+    }
+    catch (_parseError) {
+        // Fallback: el archivo no pudo parsearse — modo regex conservador
+        return processWithRegex(filepath, content, rules, profile, audit, gitStage);
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// PROCESADOR STRING-REGEX
+// Para lenguajes sin AST disponible (PHP, Python, Ruby, C#, Java, Kotlin...).
+// Usa regex para aislar el interior de strings segun la sintaxis del lenguaje
+// y aplica las reglas solo en esos fragmentos.
+// ─────────────────────────────────────────────────────────────────────────────
+// Patterns por categoria de lenguaje para extraer el interior de strings
+const STRING_PATTERNS = {
+    PHP: /(?<=")((?:[^"\\]|\\.)*?)(?=")|(?<=')((?:[^'\\]|\\.)*?)(?=')/g,
+    PYTHON: /"""([sS]*?)"""|'''([sS]*?)'''|"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)'/g,
+    RUBY: /"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)'/g,
+    CSHARP: /@"((?:[^"]|"")*)"|"((?:[^"\\]|\\.)*)"/g,
+    JAVA: /"((?:[^"\\]|\\.)*)"/g,
+    KOTLIN: /"""([sS]*?)"""|"((?:[^"\\]|\\.)*)"/g,
+    DART: /"""([sS]*?)"""|'((?:[^'\\]|\\.)*)'|"((?:[^"\\]|\\.)*)"/g,
+    MARKUP: /(?<=[a-zA-Z-]\s*=\s*)"([^"]*)"/g,
+    DATA_XML: /(?<=[a-zA-Z-]\s*=\s*)"([^"]*)"/g,
+    VUE_SVELTE: /(?<=")((?:[^"\\]|\\.)*?)(?=")|(?<=')((?:[^'\\]|\\.)*?)(?=')/g,
+};
+async function processWithStringRegex(filepath, content, rules, profile, audit, gitStage) {
+    let modified = content;
+    let corruptions = 0;
+    const pat = STRING_PATTERNS[profile.category];
+    if (pat && rules.smartQuotes) {
+        // Reemplazar solo dentro de strings reconocidos por el pattern
+        modified = modified.replace(pat, (match) => {
+            const { fixed, count } = applyEntropyRules(match, rules, profile, true);
+            corruptions += count;
+            return fixed;
+        });
+    }
+    // Resto de reglas (mojibake, zeroWidth, CRLF) son byte-level y siempre seguros
+    if (rules.mojibake && profile.allowMojibake) {
+        const { fixed: f, count: c } = MojibakeEngine_1.MojibakeEngine.cure(modified, profile.allowedMojibakeVectors);
+        if (c > 0) {
+            modified = f;
+            corruptions += c;
+        }
+    }
+    // BOM estandar y fantasma
+    if (modified.charCodeAt(0) === 0xFEFF) {
+        modified = modified.slice(1);
+        corruptions++;
+    }
+    const ghostBom = (modified.match(/\u00EF\u00BB\u00BF/g) || []).length;
+    if (ghostBom > 0) {
+        modified = modified.replace(/\u00EF\u00BB\u00BF/g, '');
+        corruptions += ghostBom;
+    }
+    if (rules.zeroWidth && profile.allowZeroWidth) {
+        const inv = /[\u200B\u200C\u200D\u202A-\u202E\u2066-\u2069]/g;
+        const c = (modified.match(inv) || []).length;
+        if (c > 0) {
+            modified = modified.replace(inv, '');
+            corruptions += c;
+        }
+        if (profile.allowNBSP) {
+            const nb = (modified.match(/\u00A0/g) || []).length;
+            if (nb > 0) {
+                modified = modified.replace(/\u00A0/g, ' ');
+                corruptions += nb;
+            }
+        }
+    }
+    if (rules.crlf && profile.allowCRLF) {
+        const c = (modified.match(/\r\n/g) || []).length;
+        if (c > 0) {
+            modified = modified.replace(/\r\n/g, '\n');
+            corruptions += c;
+        }
+    }
+    if (modified !== content) {
+        if (!audit) {
+            await promises_1.default.writeFile(filepath, modified, 'utf8');
+            if (gitStage) {
+                try {
+                    (0, child_process_1.execSync)(`git add "${filepath}"`, { cwd: path_1.default.dirname(filepath), stdio: 'ignore' });
+                }
+                catch (_) { }
+            }
+        }
+        return { filepath, corruptions, modified: true, originalContent: content };
+    }
+    return { filepath, corruptions: 0, modified: false };
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// PROCESADOR GLOBAL (Regex sin restricciones)
+// Para archivos planos: Markdown, YAML, TOML, CSS, ENV.
+// No hay sintaxis de lenguaje que pueda romperse.
+// ─────────────────────────────────────────────────────────────────────────────
+async function processWithRegex(filepath, content, rules, profile, audit, gitStage) {
+    let modified = content;
+    let corruptions = 0;
+    if (rules.mojibake && profile.allowMojibake) {
+        const { fixed: f, count: c } = MojibakeEngine_1.MojibakeEngine.cure(modified, profile.allowedMojibakeVectors);
+        if (c > 0) {
+            modified = f;
+            corruptions += c;
+        }
+    }
+    if (rules.emojis) {
+        modified = modified.replace(constants_1.EMOJI_PATTERN, (match) => {
+            const r = (0, constants_1.reverseEmojiMojibake)(match);
+            if (r !== match) {
+                corruptions++;
+                return r;
+            }
+            return match;
+        });
+    }
+    if (modified.charCodeAt(0) === 0xFEFF) {
+        modified = modified.slice(1);
+        corruptions++;
+    }
+    const ghostBom = (modified.match(/\u00EF\u00BB\u00BF/g) || []).length;
+    if (ghostBom > 0) {
+        modified = modified.replace(/\u00EF\u00BB\u00BF/g, '');
+        corruptions += ghostBom;
+    }
+    if (rules.smartQuotes && profile.smartQuoteMode === 'global') {
+        const { fixed, count } = applyEntropyRules(modified, rules, profile, true);
+        if (count > 0) {
+            modified = fixed;
+            corruptions += count;
+        }
+    }
+    if (rules.zeroWidth && profile.allowZeroWidth) {
+        const inv = /[\u200B\u200C\u200D\u202A-\u202E\u2066-\u2069]/g;
+        const c = (modified.match(inv) || []).length;
+        if (c > 0) {
+            modified = modified.replace(inv, '');
+            corruptions += c;
+        }
+        if (profile.allowNBSP) {
+            const nb = (modified.match(/\u00A0/g) || []).length;
+            if (nb > 0) {
+                modified = modified.replace(/\u00A0/g, ' ');
+                corruptions += nb;
+            }
+        }
+    }
+    if (rules.crlf && profile.allowCRLF) {
+        const c = (modified.match(/\r\n/g) || []).length;
+        if (c > 0) {
+            modified = modified.replace(/\r\n/g, '\n');
+            corruptions += c;
+        }
+    }
+    if (modified !== content) {
+        if (!audit) {
+            await promises_1.default.writeFile(filepath, modified, 'utf8');
+            if (gitStage) {
+                try {
+                    (0, child_process_1.execSync)(`git add "${filepath}"`, { cwd: path_1.default.dirname(filepath), stdio: 'ignore' });
+                }
+                catch (_) { }
+            }
+        }
+        return { filepath, corruptions, modified: true, originalContent: content };
+    }
+    return { filepath, corruptions: 0, modified: false };
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// DISPATCHER PRINCIPAL
+// Clasifica el archivo con LanguageProfiler y enruta al procesador correcto.
+// ─────────────────────────────────────────────────────────────────────────────
+async function processFile(filepath, options) {
+    if ((0, LanguageProfiler_1.isBinaryOrIgnored)(filepath)) {
+        return { filepath, corruptions: 0, modified: false };
+    }
+    try {
+        const content = await promises_1.default.readFile(filepath, 'utf8');
+        const rules = options.config.rules;
+        const profile = (0, LanguageProfiler_1.detectProfile)(filepath, content);
+        const audit = options.audit;
+        const git = options.gitStage ?? false;
+        // Archivos minificados: solo operaciones byte-level (mojibake + zeroWidth)
+        // Las reglas semanticas (smartQuotes, eradicator) quedan bloqueadas por el perfil.
+        if (profile.useAST) {
+            return processWithAST(filepath, content, rules, profile, audit, git);
+        }
+        else if (profile.smartQuoteMode === 'string-regex') {
+            return processWithStringRegex(filepath, content, rules, profile, audit, git);
+        }
+        else {
+            return processWithRegex(filepath, content, rules, profile, audit, git);
+        }
+    }
+    catch (_) {
+        return { filepath, corruptions: 0, modified: false };
+    }
+}

package/dist/3-cells/worker.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Sanitizer_1 = require("./Sanitizer");
+module.exports = async function (args) {
+    return (0, Sanitizer_1.processFile)(args.filepath, args.options);
+};