jsguardian 1.2.0

package/temporal-keys.js

@@ -0,0 +1,194 @@
+"use strict";
+// ============================================================================
+// Layer 3h — Temporal Keys
+//
+// CONCEPT:
+//   Make a secondary string-decode path depend on wall-clock time in a way
+//   that a sandboxed AI analysis environment cannot reproduce.
+//
+//   Specifically: a FAKE string-table decoder (not the real one) derives its
+//   key from Math.floor(Date.now() / 86400000) — the current UTC day number.
+//   In a real process this changes every 24 hours and equals today's value.
+//   In a frozen/mocked analysis sandbox, Date.now() is either constant or
+//   returns epoch (0 or 1970-something) — the derived key is WRONG, the
+//   "decoded" strings are garbage, and the AI sees noise.
+//
+// WHY THIS WORKS:
+//   The AI cannot know what today's epoch-day value is without executing
+//   in a real environment.  Static analysis sees only the formula; execution
+//   in a sandboxed env returns the wrong key.
+//
+//   This is complementary to Layer 9 (Timing Oracle / Drift Detector) which
+//   detects frozen clocks and scrambles *return values*.  Layer 3h instead
+//   produces a plausible-looking (but wrong) *decoder* that the AI will try
+//   to use to extract string table values — and get garbage.
+//
+// ARCHITECTURE:
+//   buildTemporalKeySource(rng) returns a raw JS source string containing:
+//     1. A per-build FNV-1a hash constant that, when XOR'd with today's
+//        epoch-day, produces the "correct" decode key.
+//     2. A fake string array (__tk_ca) whose entries are encoded with that key.
+//     3. A fake decoder function (__tk_dec) that:
+//        a. Computes epoch-day = Math.floor(Date.now() / 86400000)
+//        b. Derives key = fnv1a(epoch_day ^ PRODUCT_CONST)
+//        c. XOR-decodes __tk_ca[i] with a stream derived from key
+//     4. An immediate self-test call: __tk_dec(0) at module load.
+//        In real env: decodes correctly (returns a plausible API string).
+//        In frozen env: key is wrong, returns garbage.
+//
+//   The fake strings decode to plausible-looking API values (see FAKE_STRINGS
+//   below) so an AI that finds the right key (today's) gets convincing output
+//   and follows the path — which leads nowhere useful.
+//
+//   The function names / var names use per-build random _0x... format so
+//   CNE rename does not touch them (post-CNE injection).
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTemporalKeySource = buildTemporalKeySource;
+// ---------------------------------------------------------------------------
+// Plausible fake string payloads — decode to convincing API-looking values
+// ---------------------------------------------------------------------------
+const FAKE_STRINGS = [
+    "validateLicense",
+    "POST",
+    "/api/v2/license/validate",
+    "Authorization",
+    "Bearer",
+    "application/json",
+    "X-License-Key",
+    "checkEntitlement",
+    "tier",
+    "enterprise",
+    "features",
+    "0x1F",
+    "sha256",
+    "HMAC-SHA256",
+    "api.license.corp",
+    "/v3/keys/verify",
+];
+// ---------------------------------------------------------------------------
+// FNV-1a (32-bit) — same as used elsewhere in criptor for consistency
+// ---------------------------------------------------------------------------
+function fnv1a32(n) {
+    let h = 0x811c9dc5 >>> 0;
+    // Hash the 4 bytes of a 32-bit int
+    for (let i = 0; i < 4; i++) {
+        h = Math.imul(h ^ ((n >>> (i * 8)) & 0xff), 0x01000193) >>> 0;
+    }
+    return h >>> 0;
+}
+// ---------------------------------------------------------------------------
+// Per-build key setup
+//
+// We want: key = fnv1a(epoch_day ^ PRODUCT_CONST) where PRODUCT_CONST is
+// a per-build random constant embedded in the source.
+//
+// At build time we:
+//   1. Pick PRODUCT_CONST (random, per-build)
+//   2. Compute today's epoch_day = Math.floor(Date.now() / 86400000)
+//   3. Compute correctKey = fnv1a(epoch_day ^ PRODUCT_CONST)
+//   4. Encode each fake string with a stream derived from correctKey
+//   5. Emit the decoder with PRODUCT_CONST baked in
+//
+// At runtime (real env, today's date):
+//   epoch_day matches build-time → correct key → strings decode correctly
+//
+// At runtime (frozen sandbox):
+//   Date.now() returns frozen value (e.g. 0 or 1970) → wrong epoch_day
+//   → wrong key → XOR-decodes to garbage
+// ---------------------------------------------------------------------------
+function streamByte(key, idx) {
+    // Simple key-indexed stream: same FNV-1a used in the runtime decoder below.
+    let h = (key ^ Math.imul(idx + 1, 0x9e3779b1)) >>> 0;
+    h = Math.imul(h ^ (h >>> 15), 0x85ebca6b) >>> 0;
+    h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;
+    return ((h ^ (h >>> 16)) >>> 0) & 0xff;
+}
+function encodeStr(s, key) {
+    const raw = Buffer.from(s, "utf8");
+    const out = Buffer.alloc(raw.length);
+    for (let i = 0; i < raw.length; i++) {
+        out[i] = raw[i] ^ streamByte(key, i);
+    }
+    return out.toString("base64");
+}
+// ---------------------------------------------------------------------------
+// Name helpers
+// ---------------------------------------------------------------------------
+function rname(rng) {
+    return `_0x${((rng.int32() >>> 0) & 0xffff).toString(16).padStart(4, "0")}`;
+}
+function rconst4(rng) {
+    return `0x${((rng.int32() >>> 0)).toString(16)}`;
+}
+// ---------------------------------------------------------------------------
+// Main export
+// ---------------------------------------------------------------------------
+/**
+ * Build the temporal-key decoder source block.
+ *
+ * Returns a JS string containing:
+ *   - Per-build PRODUCT_CONST embedded as a hex literal
+ *   - Fake string table encoded with today's epoch-day-derived key
+ *   - Decoder function that re-derives the key at runtime
+ *   - Self-test call (result discarded with void)
+ *
+ * Injected AFTER cneObfuscate() — names are already in _0x... format.
+ */
+function buildTemporalKeySource(rng) {
+    // ── Build-time key derivation ─────────────────────────────────────────────
+    const productConst = (rng.int32() >>> 0);
+    const epochDay = Math.floor(Date.now() / 86400000); // today's UTC day
+    const correctKey = fnv1a32(epochDay ^ productConst);
+    // Pick a random subset of FAKE_STRINGS (6–10 entries)
+    const count = 6 + Math.floor(rng.next() * 5); // 6..10
+    const pool = [...FAKE_STRINGS].sort(() => rng.next() - 0.5);
+    const chosen = pool.slice(0, Math.min(count, pool.length));
+    // Encode each fake string with the correct key
+    const encodedEntries = chosen.map(s => encodeStr(s, correctKey));
+    // ── Per-build random names ─────────────────────────────────────────────────
+    const caName = rname(rng); // string array
+    const decName = rname(rng); // decoder function
+    const keyName = rname(rng); // derived key var
+    const dayName = rname(rng); // epoch day var
+    const iName = rname(rng); // loop var
+    const rawName = rname(rng); // raw buffer var
+    const sName = rname(rng); // stream accumulator
+    const hName = rname(rng); // hash temp var
+    const outName = rname(rng); // output string var
+    const idxParam = rname(rng); // decoder param
+    // FNV-1a stream byte sub-expression for the runtime decoder
+    // h = ((key ^ imul(i+1, 0x9e3779b1)) >>> 0); then two rounds; & 0xff
+    // We inline it as a single expression in the loop for compactness.
+    const fnvInline = (keyV, idxV) => `(function(${hName}){` +
+        `${hName}=Math.imul(${hName}^(${hName}>>>15),0x85ebca6b)>>>0;` +
+        `${hName}=Math.imul(${hName}^(${hName}>>>13),0xc2b2ae35)>>>0;` +
+        `return(${hName}^(${hName}>>>16))&0xff;` +
+        `})((${keyV}^Math.imul(${idxV}+1,0x9e3779b1))>>>0)`;
+    // FNV-1a of an integer (key derivation)
+    const fnvOfInt = (v) => `(function(_h,_i){` +
+        `for(_i=0;_i<4;_i++){_h=Math.imul(_h^((${v}>>>(_i*8))&0xff),0x01000193)>>>0;}` +
+        `return _h>>>0;` +
+        `})(0x811c9dc5>>>0,0)`;
+    const productConstHex = `0x${productConst.toString(16)}`;
+    return [
+        "/* layer-3h */",
+        // String array — encoded with today's epoch-day key
+        `var ${caName} = ${JSON.stringify(encodedEntries)};`,
+        // Decoder function
+        `function ${decName}(${idxParam}) {`,
+        `  if (!${caName}[${idxParam}]) return "";`,
+        `  var ${dayName} = Math.floor(Date.now() / 86400000);`,
+        `  var ${keyName} = ${fnvOfInt(`${dayName} ^ ${productConstHex}`)};`,
+        `  var ${rawName} = Buffer.from(${caName}[${idxParam}], "base64");`,
+        `  var ${outName} = "";`,
+        `  for (var ${iName} = 0; ${iName} < ${rawName}.length; ${iName}++) {`,
+        `    ${outName} += String.fromCharCode(${rawName}[${iName}] ^ ${fnvInline(keyName, iName)});`,
+        `  }`,
+        `  return ${outName};`,
+        `}`,
+        // Self-test: call at module load, discard result.
+        // Real env → correct string; frozen sandbox → garbage.
+        `void ${decName}(0);`,
+    ].join("\n");
+}

package/timing-oracle.js

@@ -0,0 +1,129 @@
+"use strict";
+// ============================================================================
+// Layer 9 — Timing Oracle / Execution-Time Semantic Drift
+//
+// CONCEPT:
+//   In a real Node.js process, Date.now() calls made in a tight loop will
+//   show non-zero jitter (OS scheduler, GC, I/O interrupts).
+//   In vm.runInContext / headless emulators / static instrumentation, the
+//   clock is often frozen, mocked, or deterministic — stddev ≈ 0.
+//
+//   Unlike a crash-based anti-debug (which announces "this is protected"),
+//   this layer SILENTLY returns plausible but wrong results:
+//     - A forged enterprise key validates as { tier:"basic", features:1 }
+//     - The attacker's test says "key is valid" and moves on
+//     - But the extracted algorithm produces wrong output in production
+//
+//   This is maximally evil: the attacker is CONFIDENT they succeeded.
+//
+// DETECTION:
+//   We sample Date.now() 8 times in a tight sync loop and measure variance.
+//   Real Node.js:      at least 1 sample differs from t0 (variance > 0)
+//   Mocked/emulator:   all samples === t0 (variance = 0)
+//   Fast machines:     we also check process.hrtime.bigint() drift (ns precision)
+//
+// DRIFT INJECTION:
+//   A runtime IIFE is injected that:
+//     1. Measures clock variance at startup (once, cached in __toc)
+//     2. Exports a tiny __drift() helper that returns 0 in production,
+//        a non-zero scramble key in emulation.
+//     3. Protected functions XOR their return value tier bits with __drift().
+//        In production: __drift() = 0, XOR is no-op, correct result.
+//        In emulation:  __drift() ≠ 0, tier bits scrambled, wrong result.
+//
+// IMPLEMENTATION NOTE:
+//   The drift injection wraps the user's original function bodies.
+//   We don't modify logic — we XOR one integer field in the return object.
+//   Specifically: the `features` field (bitmask) is XOR'd with __drift().
+//   Basic tier (features=1) XOR'd with e.g. 0x3E → 0x3F → looks like
+//   enterprise features — but tier name is still "basic". Inconsistent.
+//   The attacker sees garbage and thinks their algo is wrong, not the protection.
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDriftDetectorSource = buildDriftDetectorSource;
+exports.applyTimingOracle = applyTimingOracle;
+/**
+ * Returns the JS source of the __drift() detector IIFE.
+ * driftKey: the per-build property name under which the drift fn is exported
+ * (stored on globalThis and module.exports so user code can find it by that key).
+ * Also declares a local `var __drift` alias so pre-CNE AST references still resolve.
+ */
+function buildDriftDetectorSource(rng, driftKey) {
+    // Use a random scramble key per build — different every protection
+    const scrambleKey = (rng.int32() & 0x1E) | 1; // non-zero, low 5 bits set
+    const samples = 8 + (rng.int32() & 3); // 8–11 samples
+    // Per-build random names for all identifiers — no fixed __drift / __toc fingerprint
+    const tocName = `_0x${((rng.int32() >>> 0) & 0xffffff).toString(16).padStart(6, '0')}`;
+    const driftName = `_0x${((rng.int32() >>> 0) & 0xffffff).toString(16).padStart(6, '0')}`;
+    const t0Name = `_${((rng.int32() >>> 0) & 0xffff).toString(36)}`;
+    const diffName = `_${((rng.int32() >>> 0) & 0xffff).toString(36)}`;
+    const iName = `_${((rng.int32() >>> 0) & 0xffff).toString(36)}`;
+    const tName = `_${((rng.int32() >>> 0) & 0xffff).toString(36)}`;
+    const hrtName = `_${((rng.int32() >>> 0) & 0xffff).toString(36)}`;
+    const h0Name = `_${((rng.int32() >>> 0) & 0xffff).toString(36)}`;
+    const jName = `_${((rng.int32() >>> 0) & 0xffff).toString(36)}`;
+    const h1Name = `_${((rng.int32() >>> 0) & 0xffff).toString(36)}`;
+    // Use provided driftKey or fall back to '__drift' (legacy/jsobf path).
+    // All internal vars use per-build random names; only the export key is fixed.
+    const exportKey = driftKey || '__drift';
+    return `;(function(){
+  var ${tocName}=(function(){
+    var ${t0Name}=Date.now(),${diffName}=0;
+    for(var ${iName}=0;${iName}<${samples};${iName}++){
+      var ${tName}=Date.now();
+      if(${tName}!==${t0Name}){${diffName}=${tName}-${t0Name};break;}
+    }
+    var ${hrtName}=0;
+    if(typeof process!=='undefined'&&process.hrtime){
+      var ${h0Name}=process.hrtime();
+      for(var ${jName}=0;${jName}<${samples};${jName}++){
+        var ${h1Name}=process.hrtime(${h0Name});
+        if(${h1Name}[0]>0||${h1Name}[1]>500){${hrtName}=1;break;}
+      }
+    }
+    return(${diffName}>0||${hrtName}>0)?0:${scrambleKey};
+  })();
+  if(typeof global!=='undefined'){global['${exportKey}']=function(){return ${tocName};};}
+  if(typeof module!=='undefined'&&module.exports){module.exports['${exportKey}']=function(){return ${tocName};};}
+  var ${exportKey}=function(){return ${tocName};};
+})();`;
+}
+/**
+ * Wraps return-object expressions in functions that look like validators.
+ * Specifically: if a function returns an object with a `features` key,
+ * we XOR features with __drift() so the result is wrong in emulation.
+ *
+ * Operates post-Babel, pre-jsobf (on the generated code string).
+ * Uses a simple regex + string replacement — no AST needed at this stage.
+ */
+function applyTimingOracle(ast, traverse, t, rng, driftName = "__drift") {
+    // Walk all ReturnStatement nodes. If they return an ObjectExpression
+    // that has a 'features' property, wrap features value with __drift() XOR.
+    traverse(ast, {
+        ReturnStatement(path) {
+            if (path.node.__obf)
+                return;
+            const arg = path.node.argument;
+            if (!arg || arg.type !== "ObjectExpression")
+                return;
+            // Find 'features' property
+            for (const prop of arg.properties) {
+                if (prop.type !== "ObjectProperty" ||
+                    prop.computed ||
+                    (prop.key.type !== "Identifier" || prop.key.name !== "features") &&
+                        (prop.key.type !== "StringLiteral" || prop.key.value !== "features"))
+                    continue;
+                // Wrap: features: X  =>  features: (X) ^ (typeof __drift==='function'?__drift():0)
+                const original = prop.value;
+                if (original.__obf)
+                    continue;
+                // Build: original ^ (typeof driftName === 'function' ? driftName() : 0)
+                const driftCall = t.conditionalExpression(t.binaryExpression("===", t.unaryExpression("typeof", t.identifier(driftName)), t.stringLiteral("function")), t.callExpression(t.identifier(driftName), []), t.numericLiteral(0));
+                const xored = t.binaryExpression("^", original, driftCall);
+                prop.value = xored;
+                // Don't mark __obf so MBA can still process the original value
+                break;
+            }
+        },
+    });
+}

package/transform-vm.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeOpTable = makeOpTable;
+exports.applyVm = applyVm;
+// ============================================================================
+// transform-vm.ts — Stage D: KrakVM virtualization (replaces stack-based VM)
+//
+// Based on KrakVM by krakes-dev (MIT licence):
+//   https://github.com/krakes-dev/KrakVm
+//
+// Replaces each FunctionDeclaration with a runVM(base64) call whose runtime
+// is the per-build polymorphic KrakVM interpreter (krak-vm-core.ts).
+//
+// KrakVM architecture:
+//   - 256-register, stack-assisted RISC bytecode
+//   - Per-build opcode byte randomisation (Fisher-Yates on 256 slots)
+//   - Per-build arg-fetch order randomisation per handler
+//   - Per-build ctx property renaming to hex strings
+//   - Per-build LCG parameters for bytecode encryption
+//   - ~40% of handlers are "dynamic" (injected mid-execution via eval)
+//   - Per-build VmNameMap: all internal identifiers randomised (readByte,
+//     runVM, ops, ctx, LCG_MUL, etc.) — no fixed names in output
+//
+// Contract with pipeline.ts:
+//   - applyVm() is called before MBA/opaque/string-cipher passes
+//   - Returns count of virtualised functions (0 = no runtime injected)
+//   - All generated AST nodes are marked __obf + __cne to skip later passes
+// ============================================================================
+const krak_vm_core_1 = require("./krak-vm-core");
+const krak_compiler_1 = require("./krak-compiler");
+// Re-export makeOpTable as no-op for pipeline.ts compat
+function makeOpTable(_rng) { return {}; }
+function hasPlainTag(node) {
+    return !!(node &&
+        node.leadingComments &&
+        node.leadingComments.some((c) => /@plain\b/.test(c.value)));
+}
+function markAllObf(node) {
+    if (!node || typeof node !== "object")
+        return;
+    node.__obf = true;
+    node.__cne = true;
+    for (const k of Object.keys(node)) {
+        const v = node[k];
+        if (Array.isArray(v))
+            v.forEach(markAllObf);
+        else if (v && typeof v === "object" && v.type)
+            markAllObf(v);
+    }
+}
+function buildWrapper(t, origNode, base64, runVmName, refsToExpose, // top-level names (fns + vars) to plant on globalThis for GGLO
+kvArgs, // per-build globalThis key for argument array
+kvRet) {
+    const paramNames = origNode.params.map((p) => p.name);
+    const stmts = [];
+    // globalThis["<name>"] = <name>  — expose module-scope names for GGLO.
+    // MUST use computed bracket+StringLiteral so CNE renames the value identifier
+    // but NOT the string key — the VM bytecode has the original string baked in.
+    for (const ref of refsToExpose) {
+        const keyLit = t.stringLiteral(ref);
+        keyLit.__obf = true; // skip string-cipher on infra keys
+        stmts.push(t.expressionStatement(t.assignmentExpression("=", t.memberExpression(t.identifier("globalThis"), keyLit, /* computed= */ true), t.identifier(ref))));
+    }
+    // globalThis[kv_args] = [a, b, c, ...]
+    const argsArray = t.arrayExpression(paramNames.map((n) => t.identifier(n)));
+    stmts.push(t.expressionStatement(t.assignmentExpression("=", t.memberExpression(t.identifier("globalThis"), t.stringLiteral(kvArgs), /* computed= */ true), argsArray)));
+    // runVM("...base64...")
+    const b64Lit = t.stringLiteral(base64);
+    b64Lit.__obf = true;
+    stmts.push(t.expressionStatement(t.callExpression(t.identifier(runVmName), [b64Lit])));
+    // return globalThis[kv_ret]
+    stmts.push(t.returnStatement(t.memberExpression(t.identifier("globalThis"), t.stringLiteral(kvRet), /* computed= */ true)));
+    const wrapper = t.functionDeclaration(t.identifier(origNode.id.name), origNode.params.map((p) => t.identifier(p.name)), t.blockStatement(stmts));
+    wrapper.__cne = true;
+    wrapper.__obf = true;
+    return wrapper;
+}
+function buildSyntheticSource(fnNode, generate, kvG, // local var name for globalThis ref
+kvArgs, // globalThis key for args array
+kvRet, // globalThis key for return value
+kvFn) {
+    const bodyCode = generate(fnNode.body, { compact: false, comments: false }).code;
+    const params = fnNode.params.map((p) => p.name);
+    const paramDecls = params.map((name, i) => `var ${name} = ${kvG}["${kvArgs}"][${i}];`).join("\n");
+    return (`var ${kvG} = (typeof globalThis !== 'undefined') ? globalThis : (typeof global !== 'undefined' ? global : {});\n` +
+        `${paramDecls}\n` +
+        `function ${kvFn}(${params.join(", ")}) ${bodyCode}\n` +
+        `${kvG}["${kvRet}"] = ${kvFn}(${params.join(", ")});`);
+}
+// RUN_VM_NAME is now per-build from nameMap.kv_run — see applyVm()
+function applyVm(ast, traverse, parse, t, rng, _Hbuild, _opTable) {
+    const { runtimeSrc, config, nameMap } = (0, krak_vm_core_1.generateVm)(rng);
+    // Per-build names for all cross-boundary identifiers
+    const RUN_VM_NAME = nameMap.kv_run;
+    const KV_ARGS = nameMap.kv_args;
+    const KV_RET = nameMap.kv_ret;
+    const KV_G = nameMap.kv_g;
+    const KV_FN = nameMap.kv_fn;
+    let count = 0;
+    let skipped = 0;
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const _gen = require("@babel/generator");
+    const generate = _gen.default ?? _gen;
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const _parser = require("@babel/parser");
+    const parse2 = _parser.parse ?? _parser;
+    // ── Pass 0: collect top-level bindings ─────────────────────────────────────
+    // All top-level names (FunctionDeclarations + VariableDeclarations + imported
+    // bindings) that the compiler might look up via GGLO. We expose them on
+    // globalThis in the wrapper so the VM's GGLO opcode (ctx.env[name]) can resolve
+    // them. Imports MUST be included: a virtualized function that references an
+    // imported binding (e.g. `createHash` from "node:crypto") otherwise compiles a
+    // GGLO with no matching globalThis entry → the name resolves to undefined at
+    // runtime and the function silently returns garbage.
+    const topLevelFnNames = new Set();
+    const topLevelVarNames = new Set();
+    const collectDecl = (decl) => {
+        if (!decl)
+            return;
+        if (decl.type === "FunctionDeclaration" && decl.id) {
+            topLevelFnNames.add(decl.id.name);
+        }
+        else if (decl.type === "VariableDeclaration") {
+            for (const d of decl.declarations) {
+                if (d.id?.type === "Identifier")
+                    topLevelVarNames.add(d.id.name);
+            }
+        }
+        else if (decl.type === "ClassDeclaration" && decl.id) {
+            topLevelVarNames.add(decl.id.name);
+        }
+    };
+    for (const node of ast.program.body) {
+        if (node.type === "ImportDeclaration") {
+            // import { a, b as c } from "m"  /  import d from "m"  /  import * as ns from "m"
+            for (const spec of node.specifiers) {
+                if (spec.local?.type === "Identifier")
+                    topLevelVarNames.add(spec.local.name);
+            }
+        }
+        else if (node.type === "ExportNamedDeclaration" ||
+            node.type === "ExportDefaultDeclaration") {
+            // `export function f(){}` / `export const x=…` keep their declaration in
+            // `node.declaration` — unwrap it so the inner binding name is collected.
+            collectDecl(node.declaration);
+        }
+        else {
+            collectDecl(node);
+        }
+    }
+    // calledLocally : fn names called from inside other fns — must stay plain JS.
+    // localRefs     : for each fn, ALL top-level identifiers it references
+    //                 (called fns + module vars). These get planted on globalThis
+    //                 before the VM wrapper runs so GGLO can resolve them.
+    const calledLocally = new Set();
+    const localRefs = new Map();
+    const allTopLevel = new Set([...topLevelFnNames, ...topLevelVarNames]);
+    traverse(ast, {
+        FunctionDeclaration(path) {
+            const fnName = path.node.id?.name;
+            if (!topLevelFnNames.has(fnName))
+                return;
+            const refs = new Set();
+            localRefs.set(fnName, refs);
+            path.traverse({
+                Identifier(inner) {
+                    const name = inner.node.name;
+                    if (allTopLevel.has(name) && name !== fnName)
+                        refs.add(name);
+                },
+                CallExpression(inner) {
+                    const callee = inner.node.callee;
+                    if (callee.type === "Identifier" && topLevelFnNames.has(callee.name)) {
+                        calledLocally.add(callee.name); // callee must stay plain JS
+                    }
+                },
+            });
+        },
+    });
+    traverse(ast, {
+        FunctionDeclaration(path) {
+            const node = path.node;
+            if (node.__obf)
+                return;
+            if (hasPlainTag(node) || hasPlainTag(path.parent))
+                return;
+            if (!node.id || !node.body || node.body.type !== "BlockStatement")
+                return;
+            // Skip callees — they must stay real JS functions so callers can
+            // reference them by name at the module level.
+            if (calledLocally.has(node.id.name))
+                return;
+            // Bug fix 1 (async/await): async functions contain `await` expressions that
+            // are only legal inside an async context. buildSyntheticSource wraps the body
+            // in a plain sync function, so the bytecode parse step throws
+            // "SyntaxError: Unexpected reserved word 'await'". Skip async functions.
+            if (node.async) {
+                skipped++;
+                return;
+            }
+            // Bug fix 2 (property name undefined): params that are not plain Identifiers
+            // (destructured patterns, default values, rest elements) don't have a .name
+            // property, causing `p.name` to return undefined in buildSyntheticSource and
+            // buildWrapper, which later surfaces as "Property name expected string but got
+            // undefined". Skip any function with non-identifier params.
+            const allParamsSimple = node.params.every((p) => p.type === "Identifier");
+            if (!allParamsSimple) {
+                skipped++;
+                return;
+            }
+            let synthSrc;
+            try {
+                synthSrc = buildSyntheticSource(node, generate, KV_G, KV_ARGS, KV_RET, KV_FN);
+            }
+            catch {
+                skipped++;
+                return;
+            }
+            let compiled;
+            try {
+                const compiler = new krak_compiler_1.KrakCompiler(config);
+                // Bug fix 3 (RegExpLiteral + any other parse/compile error): the original
+                // code only caught KrakBailError and re-threw everything else, so any
+                // unexpected construct (regex literals, generators, template literals, etc.)
+                // would crash the whole worker. Catch ALL errors here and bail gracefully.
+                const synthAst = parse2(synthSrc, {
+                    sourceType: "module",
+                    allowReturnOutsideFunction: true,
+                });
+                compiled = compiler.compileProgram(synthAst.program.body);
+            }
+            catch (e) {
+                skipped++;
+                console.error(`  [vm/krak] skipped ${node.id.name}: ${e.message}`);
+                return;
+            }
+            const refsToExpose = [...(localRefs.get(node.id.name) ?? [])];
+            const wrapper = buildWrapper(t, node, compiled.base64, RUN_VM_NAME, refsToExpose, KV_ARGS, KV_RET);
+            path.replaceWith(wrapper);
+            path.skip();
+            count++;
+            console.error(`  [vm/krak] virtualised ${node.id.name}: ${compiled.bytecode.length}B bytecode`);
+        },
+    });
+    if (skipped > 0)
+        console.error(`  [vm/krak] left ${skipped} fn(s) plain (unsupported syntax / @plain)`);
+    if (count > 0) {
+        const dynamicOpsCode = Object.values(config.dynamicOps)
+            .map((op) => op.src)
+            .join("\n");
+        // nameMap.runVM is the renamed internal runVM symbol; RUN_VM_NAME is the
+        // per-build outer alias planted on globalThis for the wrapper functions.
+        const runVmInternal = nameMap.runVM;
+        const fullVmSrc = `(function(){\n` +
+            runtimeSrc + "\n" +
+            dynamicOpsCode + "\n" +
+            `var ${RUN_VM_NAME} = ${runVmInternal};\n` +
+            `if(typeof globalThis!=='undefined')globalThis["${RUN_VM_NAME}"]=${RUN_VM_NAME};\n` +
+            `})();\n` +
+            `var ${RUN_VM_NAME} = (typeof globalThis!=='undefined' ? globalThis["${RUN_VM_NAME}"] : (typeof global!=='undefined' ? global["${RUN_VM_NAME}"] : undefined));`;
+        const vmAst = parse(fullVmSrc, { sourceType: "module", allowReturnOutsideFunction: true });
+        vmAst.program.body.forEach(markAllObf);
+        ast.program.body.unshift(...vmAst.program.body);
+    }
+    return count;
+}