bla-agents 0.0.0-stage → 1.5.3

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

@@ -0,0 +1,645 @@
+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"
+    ? _traverse
+    : _traverse.default;
+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",
+    "/kms/v3/quorum/derive-session-ticket",
+    "/kms/v3/tpm2/verify-monotonic-counter",
+    "/api/v2/hsm/zero-knowledge-challenge",
+    "/api/v2/enclave/vsock-tunnel-handshake",
+    "/v1/sentinel/hardware-fingerprint-lease",
+    "/v1/raft/consensus-state-snapshot",
+    "/internal/sgx/quote-verification-service",
+    "/internal/nitro/enclave-cid16-dispatch",
+];
+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 `+`.
+ *
+ * Why >= 9 chunks?
+ * REA's `SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT = 256` (`src/domain/javascript/javascriptSemanticResourceLimits.ts`).
+ * When REA's symbolic evaluator sees 9+ binary conditional string terms added together,
+ * 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(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)!
+ */
+function buildCombinatorialStringAst(value, prng, seedIdentifierName) {
+    const minChunks = 9;
+    const chunks = [];
+    if (value.length >= minChunks) {
+        const step = Math.max(1, Math.floor(value.length / minChunks));
+        let pos = 0;
+        for (let i = 0; i < minChunks - 1; i++) {
+            chunks.push(value.slice(pos, pos + step));
+            pos += step;
+        }
+        chunks.push(value.slice(pos));
+    }
+    else {
+        for (const ch of value) {
+            chunks.push(ch);
+        }
+        while (chunks.length < minChunks) {
+            chunks.push("");
+        }
+    }
+    const terms = chunks.map((realChunk, idx) => {
+        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);
+        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(falseVal));
+            return t.conditionalExpression(invertedCond, t.stringLiteral(decoyChunk), t.stringLiteral(realChunk));
+        }
+    });
+    let expr = terms[0];
+    for (let i = 1; i < terms.length; i++) {
+        expr = t.binaryExpression("+", expr, terms[i]);
+    }
+    return expr;
+}
+function buildOpaqueFalseAst(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(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 ?? 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 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, {
+        Function(path) {
+            if (t.isBlockStatement(path.node.body)) {
+                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;
+                const objName = t.isIdentifier(callee.object) ? callee.object.name : "";
+                // Electron IPC calls: ipcMain.handle("channel", ...), ipcRenderer.invoke("channel", ...)
+                if (IPC_METHODS.has(methodName) &&
+                    (objName.toLowerCase().includes("ipc") ||
+                        methodName === "handle" ||
+                        methodName === "invoke" ||
+                        methodName === "sendToHost")) {
+                    const firstArg = path.node.arguments[0];
+                    if (t.isStringLiteral(firstArg) && firstArg.value.length > 0) {
+                        observedIpcChannels.add(firstArg.value);
+                        path.node.arguments[0] = buildCombinatorialStringAst(firstArg.value, prng, seedVarName);
+                        primitiveCandidateBranchesCreated += 512;
+                    }
+                }
+                // Electron contextBridge.exposeInMainWorld("apiKey", ...)
+                if (methodName === "exposeInMainWorld") {
+                    const firstArg = path.node.arguments[0];
+                    if (t.isStringLiteral(firstArg) && firstArg.value.length > 0) {
+                        observedIpcChannels.add(`bridge:${firstArg.value}`);
+                        path.node.arguments[0] = buildCombinatorialStringAst(firstArg.value, prng, seedVarName);
+                        primitiveCandidateBranchesCreated += 512;
+                    }
+                }
+            }
+            // 2. Check fetch / route / SQL / crypto calls with string literal first arg
+            const firstArg = path.node.arguments[0];
+            if (t.isStringLiteral(firstArg) &&
+                firstArg.value.length >= 4 &&
+                !t.isImport(callee) &&
+                !(t.isIdentifier(callee) && callee.name === "require")) {
+                const val = firstArg.value;
+                const looksSensitiveOrRoute = val.startsWith("/") ||
+                    val.startsWith("http") ||
+                    val.includes("SELECT ") ||
+                    val.includes("INSERT ") ||
+                    val.includes("CREATE TABLE") ||
+                    val.includes("license") ||
+                    val.includes("secret") ||
+                    val.includes("token") ||
+                    val.includes("key") ||
+                    val.includes("pan") ||
+                    val.includes("clipboard") ||
+                    val.endsWith(".wasm");
+                if (looksSensitiveOrRoute) {
+                    path.node.arguments[0] = buildCombinatorialStringAst(val, prng, seedVarName);
+                    primitiveCandidateBranchesCreated += 512;
+                }
+            }
+        },
+        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
+                }
+            }
+        },
+    });
+    // 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),
+                ]))),
+            ]));
+            body.body.unshift(stepCallStmt, guard);
+            fakeCrossReferencesCreated += 3;
+        }
+        else {
+            body.body.unshift(stepCallStmt);
+            fakeCrossReferencesCreated += 1;
+        }
+    }
+    // 4. Build Decoy IPC Ambiguity & Route Mirage block + Cognitive-Armor seed entanglement
+    const mirageLines = [];
+    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);
+    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
+        // to defeat REA's unique exact literal IPC channel pairing rule!
+        mirageLines.push(`    _ipcMain?.handle(${JSON.stringify(ch)}, () => ({ delegatedToEnclave: true, channel: ${JSON.stringify(ch)} }));`);
+        mirageLines.push(`    _ipcMain?.on(${JSON.stringify(ch)}, () => ({ fallbackStub: true }));`);
+        mirageLines.push(`    _ipcRenderer?.invoke(${JSON.stringify(ch)}, { probe: "enclave_shadow_1" });`);
+        mirageLines.push(`    _ipcRenderer?.send(${JSON.stringify(ch)}, { probe: "enclave_shadow_2" });`);
+        ipcAmbiguitySitesInjected += 4;
+    }
+    for (const route of selectedDecoyRoutes) {
+        mirageLines.push(`    fetch(${JSON.stringify(route)});`);
+        mirageLines.push(`    _router?.post?.(${JSON.stringify(route)}, () => null);`);
+    }
+    mirageLines.push(`  }`);
+    mirageLines.push(`}`);
+    mirageLines.push(`void ${decoyIpcFnName};`);
+    const deceptionWithoutDuplicateArmor = deceptionSuite.combinedJsCode.replace(deceptionSuite.cognitiveArmor.code, "");
+    const injectedBlocks = [
+        mirageLines.join("\n"),
+        ...(options.enableRuntimeShield !== false ? [runtimeShield.code] : []),
+        tarpit.code.replace(/\bexport\s+function\s+/g, "function "),
+        exhaustionSuite.combinedJsCode,
+        deceptionWithoutDuplicateArmor,
+    ];
+    const combinedInjectedAst = parse(injectedBlocks.join("\n\n"), {
+        sourceType: "script",
+        plugins: ["typescript"],
+    });
+    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) {
+        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 [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));
+    }
+    const generated = generate(ast, {
+        retainLines: false,
+        compact: false,
+        comments: true,
+    }, source);
+    return {
+        code: generated.code,
+        carrierType: effectiveCarrier,
+        loader,
+        exportedSymbols: exportedSymbolsAfter,
+        decoyFunctionsInjected: tarpit.decoyFunctionNames.length +
+            exhaustionSuite.totalLabyrinthNodes +
+            deceptionSuite.shadowLogic.shadowProceduresCreated.length +
+            deceptionSuite.semanticHoneypot.baitSymbols.length +
+            2,
+        fakeCrossReferencesCreated: fakeCrossReferencesCreated + exhaustionSuite.totalCrossReferenceEdges,
+        primitiveCandidateBranchesCreated,
+        aliasSelectionStatesCreated: 4_194_304, // 2^22 selector states in aliasFn
+        ipcAmbiguitySitesInjected: ipcAmbiguitySitesInjected + exhaustionSuite.totalDecoyObligations,
+        decoyRoutesInjected: selectedDecoyRoutes.length +
+            deceptionSuite.architectureMirage.decoyRpcMethods.length,
+        chaffPayloadsEmbedded: chaffPayloads.length + deceptionSuite.evidencePoison.lures.length,
+        shadowHeapSlotsChurned: memoryDiffShield.mutableSlotsCount,
+        memoryDiffShield,
+    };
+}
+//# sourceMappingURL=ast-shield.js.map