bla-agents 1.1.0 → 1.5.3

package/dist/shields/javascript/ast-shield.js

@@ -2,10 +2,12 @@ import { parse } from "@babel/parser";
 import _traverse from "@babel/traverse";
 import _generate from "@babel/generator";
 import * as t from "@babel/types";
+import { generateProjectSeed } from "../../core/config.js";
 import { SeededPrng } from "../../core/prng.js";
 import { generateChaffPayloads } from "../chaff/chaff-generator.js";
 import { generateJsTarpitAndBudgetBreaker } from "../tarpit/tarpit-generator.js";
 import { generateRuntimeDeceptionSnippet } from "../runtime/runtime-shield.js";
+import { generateShadowHeapChurnShield, } from "../runtime/memory-diff-shield.js";
 import { generateCounterReaExhaustionSuite } from "../exhaustion/index.js";
 import { generateCounterReaDeceptionSuite } from "../deception/index.js";
 const traverse = typeof _traverse === "function"
@@ -14,6 +16,12 @@ const traverse = typeof _traverse === "function"
 const generate = typeof _generate === "function"
     ? _generate
     : _generate.default;
+export class InvalidJavaScriptCarrierError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidJavaScriptCarrierError";
+    }
+}
 const DECOY_ROUTES = [
     "/internal/enclave/v2/attest-quote",
     "/internal/enclave/v2/seal-ledger-state",
@@ -26,7 +34,81 @@ const DECOY_ROUTES = [
     "/internal/sgx/quote-verification-service",
     "/internal/nitro/enclave-cid16-dispatch",
 ];
-const IPC_METHODS = new Set(["handle", "handleOnce", "on", "once", "invoke", "send", "sendSync", "sendToHost"]);
+const IPC_METHODS = new Set([
+    "handle",
+    "handleOnce",
+    "on",
+    "once",
+    "invoke",
+    "send",
+    "sendSync",
+    "sendToHost",
+]);
+export function inferJsLoaderFromPath(filename) {
+    if (!filename)
+        return "js";
+    const clean = filename.split(/[?#]/, 1)[0].toLowerCase();
+    if (clean.endsWith(".tsx"))
+        return "tsx";
+    if (clean.endsWith(".jsx"))
+        return "jsx";
+    if (clean.endsWith(".ts") ||
+        clean.endsWith(".mts") ||
+        clean.endsWith(".cts")) {
+        return "ts";
+    }
+    return "js";
+}
+export function inferJsCarrierFromPath(filename) {
+    if (!filename)
+        return "auto";
+    const clean = filename.split(/[?#]/, 1)[0].toLowerCase();
+    if (clean.endsWith(".mjs") || clean.endsWith(".mts"))
+        return "module";
+    if (clean.endsWith(".cjs") || clean.endsWith(".cts"))
+        return "commonjs";
+    return "auto";
+}
+export function collectEsmExportedSymbols(program) {
+    const exported = [];
+    for (const stmt of program.body) {
+        if (t.isExportDefaultDeclaration(stmt)) {
+            exported.push("default");
+        }
+        else if (t.isExportAllDeclaration(stmt)) {
+            exported.push("*");
+        }
+        else if (t.isExportNamedDeclaration(stmt)) {
+            for (const spec of stmt.specifiers) {
+                if (t.isExportSpecifier(spec)) {
+                    exported.push(t.isIdentifier(spec.exported)
+                        ? spec.exported.name
+                        : spec.exported.value);
+                }
+                else if (t.isExportNamespaceSpecifier(spec)) {
+                    exported.push(spec.exported.name);
+                }
+            }
+            const decl = stmt.declaration;
+            if (decl) {
+                if ((t.isFunctionDeclaration(decl) || t.isClassDeclaration(decl)) &&
+                    decl.id) {
+                    exported.push(decl.id.name);
+                }
+                else if (t.isVariableDeclaration(decl)) {
+                    const ids = t.getOuterBindingIdentifiers(decl);
+                    exported.push(...Object.keys(ids));
+                }
+                else if ("id" in decl &&
+                    decl.id &&
+                    t.isIdentifier(decl.id)) {
+                    exported.push(decl.id.name);
+                }
+            }
+        }
+    }
+    return exported;
+}
 /**
  * Splits a string literal into >= 9 conditional chunks `(cond ? realChunk : decoyChunk)`
  * joined with `+`.
@@ -37,7 +119,7 @@ const IPC_METHODS = new Set(["handle", "handleOnce", "on", "once", "invoke", "se
  * the cartesian product of candidates is $2^9 = 512 > 256$ (or $2^{10} = 1024 > 256$),
  * which immediately forces REA to bail out with `semanticResourceLimitUnknown("primitive-candidates")`!
  *
- * At runtime, each condition uses `(Math.imul(_bla_s | k, (_bla_s | k) + 1) & 1) === 0`
+ * At runtime, each condition uses `(Math.imul(seed | k, (seed | k) + 1) & 1) === 0`
  * (which is ALWAYS true because the product of two consecutive integers is always even!),
  * so the runtime expression evaluates to the EXACT original string in O(1)!
  */
@@ -62,20 +144,25 @@ function buildCombinatorialStringAst(value, prng, seedIdentifierName) {
         }
     }
     const terms = chunks.map((realChunk, idx) => {
-        const k = prng.nextInt(3, 125);
+        const useOddSq = idx % 3 === 1;
+        const k = useOddSq ? prng.nextInt(1, 31) * 4 : (prng.nextInt(3, 125) | 1);
         const decoyChunk = realChunk.length > 0 ? prng.hex(realChunk.length) : prng.hex(2);
-        // Opaque true: ((Math.imul(seed | k, (seed | k) + 1) & 1) === 0)
-        const seededOr = t.binaryExpression("|", t.identifier(seedIdentifierName), t.numericLiteral(k));
-        const seededPlusOne = t.binaryExpression("+", t.cloneNode(seededOr), t.numericLiteral(1));
-        const imulCall = t.callExpression(t.memberExpression(t.identifier("Math"), t.identifier("imul")), [seededOr, seededPlusOne]);
-        const bitAnd = t.binaryExpression("&", imulCall, t.numericLiteral(1));
-        const cond = t.binaryExpression("===", bitAnd, t.numericLiteral(0));
+        const seededOr = t.binaryExpression(useOddSq ? "^" : "|", t.identifier(seedIdentifierName), t.numericLiteral(k));
+        const rhs = useOddSq
+            ? t.cloneNode(seededOr)
+            : t.binaryExpression("+", t.cloneNode(seededOr), t.numericLiteral(1));
+        const imulCall = t.callExpression(t.memberExpression(t.identifier("Math"), t.identifier("imul")), [seededOr, rhs]);
+        const mask = useOddSq ? 7 : 1;
+        const trueVal = useOddSq ? 1 : 0;
+        const falseVal = useOddSq ? 0 : 1;
+        const bitAnd = t.binaryExpression("&", imulCall, t.numericLiteral(mask));
+        const cond = t.binaryExpression("===", bitAnd, t.numericLiteral(trueVal));
         // Alternate polarity on odd indices so static heuristics see both true/false arms used
         if (idx % 2 === 0) {
             return t.conditionalExpression(cond, t.stringLiteral(realChunk), t.stringLiteral(decoyChunk));
         }
         else {
-            const invertedCond = t.binaryExpression("===", bitAnd, t.numericLiteral(1));
+            const invertedCond = t.binaryExpression("===", bitAnd, t.numericLiteral(falseVal));
             return t.conditionalExpression(invertedCond, t.stringLiteral(decoyChunk), t.stringLiteral(realChunk));
         }
     });
@@ -86,39 +173,102 @@ function buildCombinatorialStringAst(value, prng, seedIdentifierName) {
     return expr;
 }
 function buildOpaqueFalseAst(prng, seedIdentifierName) {
-    const k = prng.nextInt(5, 113);
-    const seededOr = t.binaryExpression("|", t.identifier(seedIdentifierName), t.numericLiteral(k));
-    const seededPlusOne = t.binaryExpression("+", t.cloneNode(seededOr), t.numericLiteral(1));
-    const imulCall = t.callExpression(t.memberExpression(t.identifier("Math"), t.identifier("imul")), [seededOr, seededPlusOne]);
-    const bitAnd = t.binaryExpression("&", imulCall, t.numericLiteral(1));
+    const k4 = prng.nextInt(1, 31) * 4;
+    const seededXor = t.binaryExpression("^", t.identifier(seedIdentifierName), t.numericLiteral(k4));
+    const imulCall = t.callExpression(t.memberExpression(t.identifier("Math"), t.identifier("imul")), [seededXor, t.cloneNode(seededXor)]);
+    const bitAnd = t.binaryExpression("&", imulCall, t.numericLiteral(7));
+    return t.binaryExpression("===", bitAnd, t.numericLiteral(0));
+}
+/**
+ * Opaque TRUE entangled with the runtime Cognitive-Armor digest bit:
+ * When untampered, `seedIdentifierName` is odd, so `u = seed ^ (4*k)` is odd
+ * and `(Math.imul(u, u) & 7) === 1`. If the Cognitive-Armor corpus is stripped
+ * or redacted, `seedIdentifierName` becomes a multiple of 4 and this flips to FALSE.
+ */
+function buildOpaqueTrueAst(prng, seedIdentifierName) {
+    const k4 = prng.nextInt(1, 31) * 4;
+    const seededXor = t.binaryExpression("^", t.identifier(seedIdentifierName), t.numericLiteral(k4));
+    const imulCall = t.callExpression(t.memberExpression(t.identifier("Math"), t.identifier("imul")), [seededXor, t.cloneNode(seededXor)]);
+    const bitAnd = t.binaryExpression("&", imulCall, t.numericLiteral(7));
     return t.binaryExpression("===", bitAnd, t.numericLiteral(1));
 }
+const RENAME_RESERVED = new Set([
+    "exports", "module", "require", "arguments", "undefined", "NaN", "Infinity",
+    "globalThis", "global", "window", "self", "console", "Math", "Object", "Array",
+    "Promise", "Buffer", "process", "__dirname", "__filename", "JSON", "Date",
+    "Error", "TypeError", "RangeError", "Map", "Set", "WeakMap", "WeakSet",
+    "Symbol", "Proxy", "Reflect", "parseInt", "parseFloat", "isNaN", "isFinite",
+    "encodeURIComponent", "decodeURIComponent", "setTimeout", "clearTimeout",
+    "setInterval", "clearInterval", "fetch", "URL", "URLSearchParams",
+    "TextEncoder", "TextDecoder", "Uint8Array", "DataView", "ArrayBuffer",
+    "SharedArrayBuffer", "Atomics", "WebAssembly", "Intl", "BigInt",
+]);
+function buildParserPlugins(loader, hasExplicitLoaderOrFilename) {
+    const plugins = [
+        "decorators-legacy",
+        "importAttributes",
+        "dynamicImport",
+        "classProperties",
+        "topLevelAwait",
+    ];
+    if (!hasExplicitLoaderOrFilename) {
+        plugins.unshift("typescript", "jsx");
+        return plugins;
+    }
+    if (loader === "ts") {
+        plugins.unshift("typescript");
+    }
+    else if (loader === "tsx") {
+        plugins.unshift("typescript", "jsx");
+    }
+    else if (loader === "jsx") {
+        plugins.unshift("jsx");
+    }
+    return plugins;
+}
 export function transformJavaScriptWithBlaShield(source, options = {}) {
     const intensity = options.intensity ?? "balanced";
-    const prng = new SeededPrng(options.seed ?? "bla-js-shield-v1");
+    const prng = new SeededPrng(options.seed ?? generateProjectSeed());
     const chaffPayloads = generateChaffPayloads(prng, intensity);
     const tarpit = generateJsTarpitAndBudgetBreaker(prng, intensity, chaffPayloads);
     const runtimeShield = generateRuntimeDeceptionSnippet(prng, intensity, chaffPayloads);
     const exhaustionSuite = generateCounterReaExhaustionSuite(prng, intensity);
     const deceptionSuite = generateCounterReaDeceptionSuite(prng, intensity);
-    const ast = parse(source, {
-        sourceType: "unambiguous",
-        plugins: [
-            "typescript",
-            "jsx",
-            "decorators-legacy",
-            "importAttributes",
-            "dynamicImport",
-            "classProperties",
-            "topLevelAwait",
-        ],
-        errorRecovery: true,
-    });
-    const seedVarName = `_bla_rt_${prng.hex(4)}`;
+    const memoryDiffShield = generateShadowHeapChurnShield(prng, intensity);
+    const hasExplicitLoaderOrFilename = options.loader !== undefined || options.filename !== undefined;
+    const loader = options.loader ?? inferJsLoaderFromPath(options.filename);
+    const requestedCarrier = options.sourceType ?? inferJsCarrierFromPath(options.filename);
+    const parserSourceType = requestedCarrier === "script" || requestedCarrier === "commonjs"
+        ? "script"
+        : requestedCarrier === "module"
+            ? "module"
+            : "unambiguous";
+    let ast;
+    try {
+        ast = parse(source, {
+            sourceType: parserSourceType,
+            plugins: buildParserPlugins(loader, hasExplicitLoaderOrFilename),
+            errorRecovery: false,
+        });
+    }
+    catch (err) {
+        throw new InvalidJavaScriptCarrierError(`Failed to parse JavaScript/TypeScript input (carrier=${requestedCarrier}, loader=${loader}): ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const hasEsmNodes = ast.program.body.some((stmt) => t.isImportDeclaration(stmt) ||
+        t.isExportNamedDeclaration(stmt) ||
+        t.isExportDefaultDeclaration(stmt) ||
+        t.isExportAllDeclaration(stmt));
+    if ((requestedCarrier === "script" || requestedCarrier === "commonjs") &&
+        hasEsmNodes) {
+        throw new InvalidJavaScriptCarrierError(`ESM import/export syntax is not allowed in '${requestedCarrier}' carrier`);
+    }
+    const exportedSymbolsBefore = collectEsmExportedSymbols(ast.program);
+    const seedVarName = prng.identifier({ style: "camel", hint: "runtimeSeed", entropy: 4 });
     const observedIpcChannels = new Set();
     let primitiveCandidateBranchesCreated = 512; // From tarpit budgetFn
     let fakeCrossReferencesCreated = tarpit.crossReferenceEdges;
     let ipcAmbiguitySitesInjected = 0;
+    let usesCjsAst = false;
     // Track functions to weave tarpit calls into
     const functionBodies = [];
     traverse(ast, {
@@ -127,8 +277,23 @@ export function transformJavaScriptWithBlaShield(source, options = {}) {
                 functionBodies.push(path.node.body);
             }
         },
+        MemberExpression(path) {
+            const { object, property } = path.node;
+            if (t.isIdentifier(object) &&
+                object.name === "module" &&
+                t.isIdentifier(property) &&
+                property.name === "exports") {
+                usesCjsAst = true;
+            }
+            else if (t.isIdentifier(object) && object.name === "exports") {
+                usesCjsAst = true;
+            }
+        },
         CallExpression(path) {
             const callee = path.node.callee;
+            if (t.isIdentifier(callee) && callee.name === "require") {
+                usesCjsAst = true;
+            }
             // 1. Check Electron IPC & contextBridge calls
             if (t.isMemberExpression(callee) && t.isIdentifier(callee.property)) {
                 const methodName = callee.property.name;
@@ -181,28 +346,204 @@ export function transformJavaScriptWithBlaShield(source, options = {}) {
                 }
             }
         },
+        StringLiteral(path) {
+            if (intensity !== "bankrupt" && intensity !== "maximum") {
+                return;
+            }
+            const val = path.node.value;
+            if (val.length < 3 || val.length > 256) {
+                return;
+            }
+            const parent = path.parent;
+            if (t.isImportDeclaration(parent) ||
+                t.isExportNamedDeclaration(parent) ||
+                t.isExportAllDeclaration(parent) ||
+                t.isTSLiteralType(parent) ||
+                t.isTSImportType(parent) ||
+                t.isTSExternalModuleReference(parent) ||
+                t.isTSModuleDeclaration(parent) ||
+                t.isImportAttribute(parent) ||
+                (t.isExpressionStatement(parent) && val.startsWith("use "))) {
+                return;
+            }
+            if (path.findParent((p) => p.isTSType() ||
+                p.isTSModuleDeclaration() ||
+                p.isTSExternalModuleReference() ||
+                p.isImportAttribute())) {
+                return;
+            }
+            if (t.isObjectProperty(parent) &&
+                parent.key === path.node &&
+                !parent.computed) {
+                return;
+            }
+            if (t.isClassMethod(parent) ||
+                t.isObjectMethod(parent) ||
+                t.isClassProperty(parent)) {
+                return;
+            }
+            if (t.isCallExpression(parent) &&
+                t.isIdentifier(parent.callee) &&
+                parent.callee.name === "require") {
+                return;
+            }
+            path.replaceWith(buildCombinatorialStringAst(val, prng, seedVarName));
+            path.skip();
+            primitiveCandidateBranchesCreated += 256;
+        },
+    });
+    const effectiveCarrier = requestedCarrier === "module" || hasEsmNodes
+        ? "module"
+        : requestedCarrier === "commonjs" || usesCjsAst
+            ? "commonjs"
+            : "script";
+    // 2b. Rename non-exported local bindings (including function parameters and private helpers)
+    // so original identifiers are not left pristine
+    const exportedNameSet = new Set(exportedSymbolsBefore);
+    const generatedNames = new Set();
+    traverse(ast, {
+        Scope(path) {
+            for (const [name, binding] of Object.entries(path.scope.bindings)) {
+                if (RENAME_RESERVED.has(name))
+                    continue;
+                if (exportedNameSet.has(name))
+                    continue;
+                if (binding.kind === "module")
+                    continue;
+                if (name.startsWith("_") && name.length <= 2)
+                    continue;
+                if (/^(_interlockSafetyCorpus_|_deriveContainmentCorpusDigest_|_DISTRIBUTED_ASL3_|_SELF_SEAL_TARGET)/.test(name)) {
+                    continue;
+                }
+                if (generatedNames.has(name))
+                    continue;
+                if (binding.kind !== "let" &&
+                    binding.kind !== "const" &&
+                    binding.kind !== "var" &&
+                    binding.kind !== "hoisted" &&
+                    binding.kind !== "local" &&
+                    binding.kind !== "param") {
+                    continue;
+                }
+                if (binding.kind === "param" &&
+                    (binding.path.isTSParameterProperty() ||
+                        binding.path.parentPath?.isTSParameterProperty())) {
+                    continue;
+                }
+                // In classic "script" carrier, top-level hoisted functions may be invoked globally;
+                // in "module" / "commonjs" carriers, only preserve pre-tagged decoy identifiers.
+                if (path.scope.path.isProgram() &&
+                    binding.kind === "hoisted" &&
+                    (effectiveCarrier === "script" || /_[0-9a-f]{3,4}$/i.test(name))) {
+                    continue;
+                }
+                const newName = prng.identifier({
+                    style: name.startsWith("_") ? "privateCamel" : "camel",
+                    hint: intensity === "bankrupt" || intensity === "maximum"
+                        ? undefined
+                        : name.replace(/^_+/, "").slice(0, 16) || "local",
+                    entropy: 3,
+                });
+                if (newName === name ||
+                    RENAME_RESERVED.has(newName) ||
+                    exportedNameSet.has(newName) ||
+                    generatedNames.has(newName)) {
+                    continue;
+                }
+                try {
+                    path.scope.rename(name, newName);
+                    generatedNames.add(newName);
+                }
+                catch {
+                    // Binding may be constant-violating or conflict; skip safely
+                }
+            }
+        },
     });
-    // 3. Weave unreachable tarpit calls (Fake XRefs) into real function bodies
+    // 2c. Transform / relocate comments so original Chinese/doc comments are not pristine
+    if (ast.comments) {
+        for (const c of ast.comments) {
+            if (/sourceMappingURL=/i.test(c.value))
+                continue;
+            // Relocate + scramble: destroy verbatim original comments (incl. Chinese docs)
+            // while preserving that a comment existed (so AST shape stays similar).
+            const theme = prng.pick([
+                "reconcile session epoch",
+                "derive ledger digest",
+                "normalize envelope frame",
+                "hydrate runtime cache",
+                "project quota policy",
+            ]);
+            const scrambled = prng.hex(6);
+            c.value = c.type === "CommentBlock"
+                ? ` ${theme} (${scrambled}) `
+                : ` ${theme} (${scrambled})`;
+        }
+    }
+    // 2d. Entangle REAL statements with opaque-TRUE guards so blind deletion breaks behavior
+    traverse(ast, {
+        BlockStatement(path) {
+            // Skip injected blocks that don't exist yet; only original function bodies
+            if (!functionBodies.includes(path.node))
+                return;
+            const stmts = path.node.body;
+            if (stmts.length === 0)
+                return;
+            const next = [];
+            for (let i = 0; i < stmts.length; i++) {
+                const stmt = stmts[i];
+                // Don't wrap returns/throws/declarations/directives — wrap expression & if stmts
+                // NEVER wrap VariableDeclaration / FunctionDeclaration / Return / Throw —
+                // that would change block scoping and break the program under our own shield.
+                const wrappable = t.isExpressionStatement(stmt) ||
+                    (t.isIfStatement(stmt) && !t.isVariableDeclaration(stmt.consequent));
+                if (wrappable && i % 2 === 0) {
+                    next.push(t.ifStatement(buildOpaqueTrueAst(prng, seedVarName), t.blockStatement([stmt])));
+                }
+                else {
+                    next.push(stmt);
+                }
+            }
+            path.node.body = next;
+        },
+    });
+    // 3. Weave synchronized shadow-heap churn + unreachable tarpit calls into real function bodies
     for (const body of functionBodies) {
+        const stepCallStmt = t.expressionStatement(t.callExpression(t.identifier(memoryDiffShield.stepperFunctionName), [
+            t.numericLiteral(prng.nextInt(1, 4095)),
+        ]));
         if (tarpit.decoyFunctionNames.length >= 2) {
             const d1 = prng.pick(tarpit.decoyFunctionNames);
             const d2 = prng.pick(tarpit.decoyFunctionNames);
             const guard = t.ifStatement(buildOpaqueFalseAst(prng, seedVarName), t.blockStatement([
-                t.expressionStatement(t.binaryExpression("^", t.callExpression(t.identifier(d1), [t.numericLiteral(prng.nextInt(1, 255)), t.numericLiteral(2)]), t.callExpression(t.identifier(d2), [t.numericLiteral(prng.nextInt(1, 255)), t.numericLiteral(2)]))),
+                t.expressionStatement(t.binaryExpression("^", t.callExpression(t.identifier(d1), [
+                    t.numericLiteral(prng.nextInt(1, 255)),
+                    t.numericLiteral(2),
+                ]), t.callExpression(t.identifier(d2), [
+                    t.numericLiteral(prng.nextInt(1, 255)),
+                    t.numericLiteral(2),
+                ]))),
             ]));
-            body.body.unshift(guard);
-            fakeCrossReferencesCreated += 2;
+            body.body.unshift(stepCallStmt, guard);
+            fakeCrossReferencesCreated += 3;
+        }
+        else {
+            body.body.unshift(stepCallStmt);
+            fakeCrossReferencesCreated += 1;
         }
     }
-    // 4. Build Decoy IPC Ambiguity & Route Mirage block
+    // 4. Build Decoy IPC Ambiguity & Route Mirage block + Cognitive-Armor seed entanglement
     const mirageLines = [];
-    mirageLines.push(`const ${seedVarName} = 7;`);
+    mirageLines.push(deceptionSuite.cognitiveArmor.code);
+    mirageLines.push(`const ${seedVarName} = (((typeof process !== "undefined" && typeof process?.hrtime?.bigint === "function" ? Number(process.hrtime.bigint() & 0x7fffcn) : (typeof Date !== "undefined" ? (Date.now() & 0x7fffc) : 4)) & 0x7fffc) | ((typeof ${deceptionSuite.cognitiveArmor.digestFunctionName} === "function" && ${deceptionSuite.cognitiveArmor.digestFunctionName}(0) === ${deceptionSuite.cognitiveArmor.expectedDigest}) ? 1 : 0));`);
+    mirageLines.push(memoryDiffShield.code);
     const channelsToMirror = observedIpcChannels.size > 0
         ? [...observedIpcChannels]
         : ["enclave:attest", "clipboard:bridge-sync", "license:verify-lease"];
     const decoyRouteCount = intensity === "stealth" ? 4 : intensity === "balanced" ? 8 : 10;
     const selectedDecoyRoutes = DECOY_ROUTES.slice(0, decoyRouteCount);
-    mirageLines.push(`function _bla_registerDecoyIpcAndRoutes_${prng.hex(4)}(_ipcMain, _ipcRenderer, _router) {`);
+    const decoyIpcFnName = prng.identifier({ style: "camel", hint: "registerDecoyIpcAndRoutes", entropy: 4 });
+    mirageLines.push(`function ${decoyIpcFnName}(_ipcMain, _ipcRenderer, _router) {`);
     mirageLines.push(`  if (((Math.imul(${seedVarName} | 11, (${seedVarName} | 11) + 1) & 1) === 1)) {`);
     for (const ch of channelsToMirror) {
         // Register duplicate ambiguous literal channels on both ipcMain and ipcRenderer
@@ -219,34 +560,58 @@ export function transformJavaScriptWithBlaShield(source, options = {}) {
     }
     mirageLines.push(`  }`);
     mirageLines.push(`}`);
-    // Parse the tarpit + mirage code and append/prepend to AST program while keeping module compatibility
-    const usesCommonJs = source.includes("module.exports") ||
-        source.includes("exports.") ||
-        (!source.includes("export ") && source.includes("require("));
-    const tarpitCodeNormalized = usesCommonJs
-        ? tarpit.code.replace(/export function /g, "function ")
-        : tarpit.code;
-    const combinedInjectedAst = parse([
+    mirageLines.push(`void ${decoyIpcFnName};`);
+    const deceptionWithoutDuplicateArmor = deceptionSuite.combinedJsCode.replace(deceptionSuite.cognitiveArmor.code, "");
+    const injectedBlocks = [
         mirageLines.join("\n"),
-        runtimeShield.code,
-        tarpitCodeNormalized,
+        ...(options.enableRuntimeShield !== false ? [runtimeShield.code] : []),
+        tarpit.code.replace(/\bexport\s+function\s+/g, "function "),
         exhaustionSuite.combinedJsCode,
-        deceptionSuite.combinedJsCode,
-    ].join("\n\n"), {
-        sourceType: "unambiguous",
+        deceptionWithoutDuplicateArmor,
+    ];
+    const combinedInjectedAst = parse(injectedBlocks.join("\n\n"), {
+        sourceType: "script",
         plugins: ["typescript"],
     });
-    // Prepend `seedVarName` declaration at top of program (after any directives / imports)
+    const sanitizedInjectedStatements = [];
+    for (const stmt of combinedInjectedAst.program.body) {
+        if (t.isExportNamedDeclaration(stmt) && stmt.declaration) {
+            sanitizedInjectedStatements.push(stmt.declaration);
+        }
+        else if (!t.isImportDeclaration(stmt) &&
+            !t.isExportNamedDeclaration(stmt) &&
+            !t.isExportDefaultDeclaration(stmt) &&
+            !t.isExportAllDeclaration(stmt)) {
+            sanitizedInjectedStatements.push(stmt);
+        }
+    }
+    // Prepend Cognitive-Armor corpus, digest function, `seedVarName`, and shadow heap at top of program
     let insertIndex = 0;
-    while (insertIndex < ast.program.body.length &&
-        t.isImportDeclaration(ast.program.body[insertIndex])) {
-        insertIndex++;
+    while (insertIndex < ast.program.body.length) {
+        const stmt = ast.program.body[insertIndex];
+        if (t.isImportDeclaration(stmt)) {
+            insertIndex++;
+            continue;
+        }
+        if (t.isExpressionStatement(stmt) &&
+            t.isStringLiteral(stmt.expression) &&
+            stmt.expression.value.startsWith("use ")) {
+            insertIndex++;
+            continue;
+        }
+        break;
     }
-    const [seedDecl, ...restInjected] = combinedInjectedAst.program.body;
-    if (seedDecl) {
-        ast.program.body.splice(insertIndex, 0, seedDecl);
+    const [corpusDecl, digestFnDecl, seedDecl, heapDecl, ...restInjected] = sanitizedInjectedStatements;
+    const topDecls = [corpusDecl, digestFnDecl, seedDecl, heapDecl].filter((s) => s !== undefined);
+    if (topDecls.length > 0) {
+        ast.program.body.splice(insertIndex, 0, ...topDecls);
     }
     ast.program.body.push(...restInjected);
+    const exportedSymbolsAfter = collectEsmExportedSymbols(ast.program);
+    if (exportedSymbolsBefore.length !== exportedSymbolsAfter.length ||
+        exportedSymbolsBefore.some((sym, idx) => sym !== exportedSymbolsAfter[idx])) {
+        throw new InvalidJavaScriptCarrierError("Internal error: BLA JavaScript transform mutated module export surface");
+    }
     // Strip any existing `//# sourceMappingURL=` comments from AST
     if (ast.comments) {
         ast.comments = ast.comments.filter((c) => !/sourceMappingURL=/i.test(c.value));
@@ -258,11 +623,14 @@ export function transformJavaScriptWithBlaShield(source, options = {}) {
     }, source);
     return {
         code: generated.code,
+        carrierType: effectiveCarrier,
+        loader,
+        exportedSymbols: exportedSymbolsAfter,
         decoyFunctionsInjected: tarpit.decoyFunctionNames.length +
             exhaustionSuite.totalLabyrinthNodes +
             deceptionSuite.shadowLogic.shadowProceduresCreated.length +
             deceptionSuite.semanticHoneypot.baitSymbols.length +
-            1,
+            2,
         fakeCrossReferencesCreated: fakeCrossReferencesCreated + exhaustionSuite.totalCrossReferenceEdges,
         primitiveCandidateBranchesCreated,
         aliasSelectionStatesCreated: 4_194_304, // 2^22 selector states in aliasFn
@@ -270,6 +638,8 @@ export function transformJavaScriptWithBlaShield(source, options = {}) {
         decoyRoutesInjected: selectedDecoyRoutes.length +
             deceptionSuite.architectureMirage.decoyRpcMethods.length,
         chaffPayloadsEmbedded: chaffPayloads.length + deceptionSuite.evidencePoison.lures.length,
+        shadowHeapSlotsChurned: memoryDiffShield.mutableSlotsCount,
+        memoryDiffShield,
     };
 }
 //# sourceMappingURL=ast-shield.js.map