optipack 0.0.0-stage → 1.0.0

package/src/passes/b5-null-chain-flatten.js

@@ -0,0 +1,137 @@
+/**
+ * B5 null-chain-flatten — balanced level.
+ *
+ * After S1/S2 prove a guard, `a?.b` becomes `a.b` when `a` is statically
+ * non-nullish in that region: a guard like `if (!a) return;` (or
+ * `if (a == null) throw ...`) dominates the following statements, and nothing
+ * can reassign `a` before the use. The guard window is barrier-aware: a
+ * statement containing calls flattens its own uses only when no call executes
+ * before them (evaluation-order corridor), and then ends the window.
+ *
+ * Only the FIRST optional hop rooted at the guarded identifier is flattened;
+ * deeper optional hops (`a?.b?.c`) remain — `a.b` itself may still be nullish.
+ */
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import { walkSameFunction, corridorSafe } from '../pass-utils.js';
+
+const _traverse = traverse.default || traverse;
+
+export const ID = 'null-chain-flatten';
+export const CODE = 'B5';
+
+function statementHasBarrier(stmt) {
+  let barrier = false;
+  walkSameFunction(stmt, (n) => {
+    if (t.isCallExpression(n) || t.isNewExpression(n) || t.isAssignmentExpression(n) ||
+        t.isUpdateExpression(n) || t.isAwaitExpression(n) || t.isYieldExpression(n) ||
+        t.isForOfStatement(n) || t.isForInStatement(n) ||
+        t.isForStatement(n) || t.isWhileStatement(n) || t.isDoWhileStatement(n) ||
+        t.isTaggedTemplateExpression(n)) {
+      barrier = true;
+      return false;
+    }
+    return true;
+  });
+  return barrier;
+}
+
+/** Does this statement (or block) always exit? */
+function alwaysExits(stmt) {
+  if (!stmt) return false;
+  if (t.isReturnStatement(stmt) || t.isThrowStatement(stmt) ||
+      t.isBreakStatement(stmt) || t.isContinueStatement(stmt)) return true;
+  if (t.isBlockStatement(stmt)) {
+    if (stmt.body.length === 0) return false;
+    for (const s of stmt.body) {
+      if (t.isIfStatement(s) || t.isSwitchStatement(s)) return false;
+    }
+    return alwaysExits(stmt.body[stmt.body.length - 1]);
+  }
+  return false;
+}
+
+/** Matches `!a`, `a == null`, `a === null`, `a == undefined`, `a === undefined`,
+ *  and `a === null || a === undefined` combinations. Returns the identifier or null. */
+function guardIdent(test) {
+  const idOf = (n) => (t.isIdentifier(n) ? n : null);
+
+  if (t.isUnaryExpression(test) && test.operator === '!') return idOf(test.argument);
+
+  const eqNullish = (n) => {
+    if (!t.isBinaryExpression(n)) return false;
+    if (n.operator !== '==' && n.operator !== '===') return false;
+    const { left, right } = n;
+    const litNull = t.isNullLiteral(right) || (t.isIdentifier(right) && right.name === 'undefined');
+    const litNullL = t.isNullLiteral(left) || (t.isIdentifier(left) && left.name === 'undefined');
+    return (idOf(left) && litNull) || (idOf(right) && litNullL);
+  };
+  if (eqNullish(test)) {
+    if (t.isBinaryExpression(test)) {
+      return idOf(t.isIdentifier(test.left) ? test.left : test.right);
+    }
+  }
+  if (t.isLogicalExpression(test) && test.operator === '||') {
+    const l = guardIdent(test.left);
+    const r = guardIdent(test.right);
+    if (l && r && l.name === r.name) return l;
+  }
+  return null;
+}
+
+export default function nullChainFlatten(programPath, ctx) {
+  programPath.traverse({
+    BlockStatement(path) {
+      const body = path.node.body;
+      for (let i = 0; i < body.length; i++) {
+        const stmt = body[i];
+        if (!t.isIfStatement(stmt)) continue;
+        if (!alwaysExits(stmt.consequent)) continue;
+        if (stmt.alternate && !alwaysExits(stmt.alternate)) continue;
+        const ident = guardIdent(stmt.test);
+        if (!ident) continue;
+        if (ctx.isDisabled(path, ID, CODE)) continue;
+
+        const binding = path.scope.getBinding(ident.name);
+        if (!binding) continue; // need a trackable local/param
+        if (binding.constantViolations.length > 0) {
+          ctx.bail(stmt.loc ? stmt.loc.start.line : 0, CODE,
+            `guarded identifier "${ident.name}" is reassigned in scope`);
+          continue;
+        }
+
+        // Barrier-aware window after the guard.
+        let applied = 0;
+        for (let j = i + 1; j < body.length; j++) {
+          const s = body[j];
+          // Collect optional chains rooted at ident in this statement.
+          const uses = [];
+          walkSameFunction(s, (n) => {
+            if (t.isOptionalMemberExpression(n) && n.optional &&
+                t.isIdentifier(n.object) && n.object.name === ident.name) {
+              uses.push(n);
+            } else if (t.isOptionalCallExpression(n) && n.optional &&
+                t.isIdentifier(n.callee) && n.callee.name === ident.name) {
+              uses.push(n);
+            }
+            return true;
+          });
+          if (uses.length === 0) {
+            if (statementHasBarrier(s)) break; // window ends at barriers
+            continue;
+          }
+          if (corridorSafe(s, uses)) {
+            for (const n of uses) {
+              n.optional = false;
+              applied++;
+            }
+          } else {
+            break;
+          }
+          if (statementHasBarrier(s)) break; // window ends at barriers
+        }
+        if (applied > 0) ctx.applied(ID);
+      }
+    },
+  });
+}

package/src/passes/index.js

@@ -0,0 +1,43 @@
+/**
+ * Ordered pass registry. Running level N enables all passes at level <= N.
+ */
+import * as s1 from './s1-const-fold.js';
+import * as s2 from './s2-dead-code.js';
+import * as s3 from './s3-bool-simplify.js';
+import * as s4 from './s4-for-of-to-indexed.js';
+import * as s5 from './s5-array-methods-to-loops.js';
+import * as s6 from './s6-destructure-to-direct.js';
+import * as s7 from './s7-hoist-invariant-members.js';
+import * as b1 from './b1-cache-getter-chains.js';
+import * as b2 from './b2-closure-lift.js';
+import * as b3 from './b3-string-build.js';
+import * as b4 from './b4-dynprop-hoist.js';
+import * as b5 from './b5-null-chain-flatten.js';
+import * as r1 from './r1-cross-tick-cache.js';
+import * as r2 from './r2-json-fold.js';
+import * as r3 from './r3-try-catch-strip.js';
+import * as r4 from './r4-getter-cache-cross-barrier.js';
+
+export const PASSES = [
+  { code: 'S1', id: s1.ID, level: 'safe', run: s1.default },
+  { code: 'S2', id: s2.ID, level: 'safe', run: s2.default },
+  { code: 'S3', id: s3.ID, level: 'safe', run: s3.default },
+  { code: 'S4', id: s4.ID, level: 'safe', run: s4.default },
+  { code: 'S5', id: s5.ID, level: 'safe', run: s5.default },
+  { code: 'S6', id: s6.ID, level: 'safe', run: s6.default },
+  { code: 'S7', id: s7.ID, level: 'safe', run: s7.default },
+  { code: 'B1', id: b1.ID, level: 'balanced', run: b1.default },
+  { code: 'B2', id: b2.ID, level: 'balanced', run: b2.default },
+  { code: 'B3', id: b3.ID, level: 'balanced', run: b3.default },
+  { code: 'B4', id: b4.ID, level: 'balanced', run: b4.default },
+  { code: 'B5', id: b5.ID, level: 'balanced', run: b5.default },
+  { code: 'R1', id: r1.ID, level: 'risky', run: r1.default },
+  { code: 'R2', id: r2.ID, level: 'risky', run: r2.default },
+  { code: 'R3', id: r3.ID, level: 'risky', run: r3.default },
+  { code: 'R4', id: r4.ID, level: 'risky', run: r4.default },
+];
+
+export const PASS_BY_ID = new Map(PASSES.map((p) => [p.id, p]));
+export const PASS_BY_CODE = new Map(PASSES.map((p) => [p.code, p]));
+export const PASS_IDS = new Set(PASSES.map((p) => p.id));
+export const PASS_CODES = new Map(PASSES.map((p) => [p.code, p.id]));

package/src/passes/r1-cross-tick-cache.js

@@ -0,0 +1,192 @@
+/**
+ * R1 cross-tick-cache — RISKY.
+ *
+ * Module-level WeakMap caches keyed by entity/player for
+ * `getComponent("...")` results and for immutable-per-entity fields
+ * (`entity.id`, `entity.typeId`), reused across ticks with no invalidation.
+ *
+ * Failure mode: stale component views after death / dimension change. Even the
+ * immutable subset is reported as risky (a hostile addon could mutate id).
+ *
+ * Applied to reads inside hot functions only. Every application emits a
+ * warning in the report.
+ */
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+
+const _traverse = traverse.default || traverse;
+
+export const ID = 'cross-tick-cache';
+export const CODE = 'R1';
+
+function isWriteTargetPath(memberPath) {
+  const parent = memberPath.parent;
+  if (t.isAssignmentExpression(parent) && parent.left === memberPath.node) return true;
+  if (t.isUpdateExpression(parent) && parent.argument === memberPath.node) return true;
+  if (t.isUnaryExpression(parent) && parent.operator === 'delete' && parent.argument === memberPath.node) return true;
+  return false;
+}
+
+export default function crossTickCache(programPath, ctx) {
+  const edits = []; // { kind: 'component'|'field', line, node, stmt, recvNode, key }
+  let sawAny = false;
+
+  programPath.traverse({
+    'FunctionDeclaration|FunctionExpression|ArrowFunctionExpression'(path) {
+      const fn = path.node;
+      if (!ctx.isHot(fn)) return;
+      if (ctx.isDisabled(path, ID, CODE)) return;
+
+      // ---- component reads: X.getComponent("lit")
+      path.traverse({
+        CallExpression(cp) {
+          const n = cp.node;
+          if (cp.parentPath && isWriteTargetCall(cp)) return;
+          if (!(t.isMemberExpression(n.callee) && !n.callee.computed &&
+                t.isIdentifier(n.callee.property) && n.callee.property.name === 'getComponent' &&
+                n.arguments.length === 1 && t.isStringLiteral(n.arguments[0]))) return;
+          const obj = n.callee.object;
+          if (!t.isIdentifier(obj) && !t.isThisExpression(obj)) return;
+          edits.push({
+            kind: 'component',
+            line: n.loc ? n.loc.start.line : 0,
+            node: n,
+            fnPath: path,
+            recvName: t.isIdentifier(obj) ? obj.name : null,
+            isThis: t.isThisExpression(obj),
+            key: n.arguments[0].value,
+          });
+        },
+        MemberExpression(mp) {
+          const n = mp.node;
+          if (isWriteTargetPath(mp)) return;
+          if (mp.parentPath && t.isCallExpression(mp.parentPath.node) && mp.parentPath.node.callee === n) return;
+          if (!(!n.computed && t.isIdentifier(n.property) && (n.property.name === 'id' || n.property.name === 'typeId'))) return;
+          const obj = n.object;
+          if (!t.isIdentifier(obj)) return;
+          edits.push({
+            kind: 'field',
+            line: n.loc ? n.loc.start.line : 0,
+            node: n,
+            fnPath: path,
+            recvName: obj.name,
+            isThis: false,
+            key: n.property.name,
+          });
+        },
+      });
+    },
+  });
+
+  if (edits.length === 0) return;
+
+  // Group by (receiver identity, key) to share cache slots; rewrite within the
+  // owning statement.
+  const seen = new Set();
+  for (const e of edits) {
+    if (seen.has(e.node)) continue;
+    seen.add(e.node);
+    const helper = e.kind === 'component' ? '__opR1Component' : '__opR1Field';
+    const recv = e.isThis ? t.thisExpression() : t.identifier(e.recvName);
+    const call = t.callExpression(t.identifier(helper), [recv, t.stringLiteral(e.key)]);
+    // Replace within the enclosing hot function body subtree.
+    const root = e.fnPath.node.body;
+    if (replaceInTree(root, e.node, call)) {
+      sawAny = true;
+      ctx.applied(ID);
+      ctx.warn(e.line, CODE,
+        e.kind === 'component'
+          ? `getComponent("${e.key}") cached across ticks in a WeakMap — stale after death/dimension change`
+          : `.${e.key} cached across ticks in a WeakMap — stale if mutated`);
+    }
+  }
+
+  if (sawAny) {
+    injectHelpers(programPath);
+  }
+}
+
+function isWriteTargetCall(cp) {
+  const parent = cp.parentPath && cp.parentPath.node;
+  return t.isAssignmentExpression(parent) && parent.left === cp.node;
+}
+
+function replaceInTree(rootNode, oldNode, newNode) {
+  const stack = [rootNode];
+  while (stack.length > 0) {
+    const cur = stack.pop();
+    if (!cur || typeof cur !== 'object') continue;
+    for (const key of Object.keys(cur)) {
+      if (key === 'loc' || key === 'leadingComments' || key === 'trailingComments' || key === 'innerComments' || key === 'extra') continue;
+      const v = cur[key];
+      if (v === oldNode) { cur[key] = newNode; return true; }
+      if (Array.isArray(v)) {
+        const idx = v.indexOf(oldNode);
+        if (idx >= 0) { v[idx] = newNode; return true; }
+        for (const item of v) if (item && typeof item === 'object' && typeof item.type === 'string') stack.push(item);
+      } else if (v && typeof v === 'object' && typeof v.type === 'string') {
+        stack.push(v);
+      }
+    }
+  }
+  return false;
+}
+
+function injectHelpers(programPath) {
+  const body = programPath.node.body;
+  let lastImport = -1;
+  for (let i = 0; i < body.length; i++) {
+    if (t.isImportDeclaration(body[i])) lastImport = i;
+  }
+  body.splice(lastImport + 1, 0, ...buildHelperStatements());
+}
+
+function buildHelperStatements() {
+  const cacheMap = t.identifier('__opR1Cache');
+
+  const cacheGetFn = (name, readExpr) => {
+    // function name(obj, key) { ... }
+    const obj = t.identifier('obj');
+    const key = t.identifier('key');
+    const m = t.identifier('m');
+    const v = t.identifier('v');
+    return t.functionDeclaration(
+      t.identifier(name),
+      [obj, key],
+      t.blockStatement([
+        t.variableDeclaration('let', [t.variableDeclarator(m,
+          t.callExpression(t.memberExpression(cacheMap, t.identifier('get')), [obj]))]),
+        t.ifStatement(
+          t.binaryExpression('===', m, t.identifier('undefined')),
+          t.blockStatement([
+            t.expressionStatement(t.assignmentExpression('=', m,
+              t.newExpression(t.identifier('Map'), []))),
+            t.expressionStatement(t.callExpression(
+              t.memberExpression(cacheMap, t.identifier('set')), [obj, m])),
+          ])
+        ),
+        t.variableDeclaration('let', [t.variableDeclarator(v,
+          t.callExpression(t.memberExpression(m, t.identifier('get')), [key]))]),
+        t.ifStatement(
+          t.binaryExpression('===', v, t.identifier('undefined')),
+          t.blockStatement([
+            t.expressionStatement(t.assignmentExpression('=', v, readExpr(obj, key))),
+            t.expressionStatement(t.callExpression(
+              t.memberExpression(m, t.identifier('set')), [key, v])),
+          ])
+        ),
+        t.returnStatement(v),
+      ])
+    );
+  };
+
+  return [
+    t.variableDeclaration('const', [
+      t.variableDeclarator(cacheMap, t.newExpression(t.identifier('WeakMap'), [])),
+    ]),
+    cacheGetFn('__opR1Component', (obj, key) =>
+      t.callExpression(t.memberExpression(obj, t.identifier('getComponent')), [key])),
+    cacheGetFn('__opR1Field', (obj, key) =>
+      t.memberExpression(obj, key, true)),
+  ];
+}

package/src/passes/r2-json-fold.js

@@ -0,0 +1,201 @@
+/**
+ * R2 json-fold — RISKY.
+ *
+ * `const x = JSON.parse('{"a":1}')` on a constant string is hoisted to a
+ * module-level `const` shared by every call site, when the tool can prove the
+ * parsed object is never mutated and never escapes to unknown code.
+ *
+ * Failure mode: shared mutable state if any code mutates the parsed object.
+ *
+ * Proof obligations (else bail):
+ *  - the string literal must parse as JSON at build time
+ *  - binding is `const`, never reassigned
+ *  - every use is a pure READ: member-access object position, arithmetic /
+ *    comparison / logical / unary (non-delete) operand, template substitution,
+ *    conditional test — nothing else
+ *  - never passed to any function (even known ones), never returned, thrown,
+ *    spread, aliased, iterated (for-of), or stored in another object/array
+ *  - no method call on it (x.reset() could mutate)
+ *
+ * Every application emits a warning in the report.
+ */
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+
+const _traverse = traverse.default || traverse;
+
+export const ID = 'json-fold';
+export const CODE = 'R2';
+
+export default function jsonFold(programPath, ctx) {
+  const folds = [];
+
+  programPath.traverse({
+    VariableDeclarator(path) {
+      const node = path.node;
+      const decl = path.parentPath.node;
+      if (!t.isVariableDeclaration(path.parentPath.node) || path.parentPath.node.kind !== 'const') return;
+      if (path.parentPath.node.declarations.length !== 1) return;
+      if (!t.isIdentifier(node.id)) return;
+      const init = node.init;
+      if (!init || !t.isCallExpression(init)) return;
+      const callee = init.callee;
+      if (!(t.isMemberExpression(callee) && t.isIdentifier(callee.object) &&
+            callee.object.name === 'JSON' && t.isIdentifier(callee.property) &&
+            callee.property.name === 'parse' && init.arguments.length === 1)) return;
+      const arg = init.arguments[0];
+      if (!t.isStringLiteral(arg)) return;
+      const line = node.loc ? node.loc.start.line : 0;
+      if (ctx.isDisabled(path, ID, CODE)) return;
+
+      // The literal must actually parse.
+      let parsed;
+      try {
+        parsed = JSON.parse(arg.value);
+      } catch (e) {
+        ctx.bail(line, CODE, `literal is not valid JSON: ${e.message}`);
+        return;
+      }
+      void parsed;
+
+      const name = node.id.name;
+      const binding = path.scope.getBinding(name);
+      if (!binding) return;
+      if (binding.constantViolations.length > 0) {
+        ctx.bail(line, CODE, 'binding is reassigned');
+        return;
+      }
+
+      // Exported bindings never fold.
+      let up = path.parentPath;
+      let exported = false;
+      while (up) {
+        if (up.isExportNamedDeclaration() || up.isExportDefaultDeclaration()) { exported = true; break; }
+        up = up.parentPath;
+      }
+      if (exported) {
+        ctx.bail(line, CODE, 'binding is exported');
+        return;
+      }
+
+      // Verify every use is a pure read. The parsed value is known at build
+      // time, so property reads of primitive JSON values are safe to pass
+      // anywhere (a copy flows); the object itself never escapes.
+      let ok = true;
+      let failReason = null;
+      for (const ref of binding.referencePaths) {
+        const verdict = isPureReadUse(ref, name, parsed);
+        if (!verdict.ok) { ok = false; failReason = verdict.reason; break; }
+      }
+      if (!ok) {
+        ctx.bail(line, CODE, failReason || 'use is not a pure read');
+        return;
+      }
+
+      folds.push({ path, name, literal: t.cloneNode(arg, true), line, refs: [...binding.referencePaths] });
+    },
+  });
+
+  if (folds.length === 0) return;
+
+  const body = programPath.node.body;
+  let lastImport = -1;
+  for (let i = 0; i < body.length; i++) {
+    if (t.isImportDeclaration(body[i])) lastImport = i;
+  }
+
+  const newStmts = [];
+  let idx = 1;
+  for (const f of folds) {
+    const hoistName = programPath.scope.generateUid('opJson');
+    newStmts.push(t.variableDeclaration('const', [
+      t.variableDeclarator(t.identifier(hoistName),
+        t.callExpression(t.memberExpression(t.identifier('JSON'), t.identifier('parse')), [f.literal])),
+    ]));
+    for (const ref of f.refs) {
+      if (ref.node) ref.replaceWith(t.identifier(hoistName));
+    }
+    f.path.remove();
+    ctx.applied(ID);
+    ctx.warn(f.line, CODE,
+      `JSON.parse(${JSON.stringify(truncate(f.literal.value))}) hoisted to module scope — shared mutable object`);
+    idx++;
+  }
+  void idx;
+
+  body.splice(lastImport + 1, 0, ...newStmts);
+}
+
+function truncate(s) {
+  return s.length > 40 ? s.slice(0, 37) + '...' : s;
+}
+
+/**
+ * Walk from a reference up to the nearest statement; every intermediate node
+ * must be a read-safe context. When the value escapes into a call argument,
+ * return, throw, etc., the escape is safe only if a member dereference happened
+ * on the way AND the JSON value at that path is a primitive.
+ */
+function isPureReadUse(ref, name, parsed) {
+  let p = ref.parentPath;
+  let prev = ref.node;
+  const propPath = []; // property names dereferenced so far
+  const escapeSafe = () => {
+    if (propPath.length === 0) return false; // the raw object escapes
+    let v = parsed;
+    for (const k of propPath) {
+      if (v === null || typeof v !== 'object') return true; // dereferenced past a primitive
+      v = v[k];
+    }
+    return v === null || typeof v !== 'object'; // primitive value flows: a copy
+  };
+  while (p && !p.isStatement()) {
+    const n = p.node;
+    if (t.isMemberExpression(n) || t.isOptionalMemberExpression(n)) {
+      if (n.object !== prev) return { ok: false, reason: 'used as a property key' };
+      if (t.isIdentifier(n.property)) propPath.push(n.property.name);
+      else if (t.isStringLiteral(n.property)) propPath.push(n.property.value);
+      // A method call on the parsed object could mutate it.
+      const pp = p.parentPath;
+      if (pp && t.isCallExpression(pp.node) && pp.node.callee === n) {
+        return { ok: false, reason: 'method called on the parsed object' };
+      }
+      if (pp && (t.isAssignmentExpression(pp.node) && pp.node.left === n)) {
+        return { ok: false, reason: 'property of the parsed object is written' };
+      }
+      if (pp && (t.isUpdateExpression(pp.node) && pp.node.argument === n)) {
+        return { ok: false, reason: 'property of the parsed object is updated' };
+      }
+      if (pp && t.isUnaryExpression(pp.node) && pp.node.operator === 'delete' && pp.node.argument === n) {
+        return { ok: false, reason: 'property of the parsed object is deleted' };
+      }
+      prev = n;
+      p = p.parentPath;
+      continue;
+    }
+    if (t.isBinaryExpression(n) || t.isLogicalExpression(n) || t.isUnaryExpression(n) ||
+        t.isConditionalExpression(n) || t.isTemplateLiteral(n)) {
+      if (t.isUnaryExpression(n) && n.operator === 'delete') {
+        return { ok: false, reason: 'delete of parsed object property' };
+      }
+      prev = n;
+      p = p.parentPath;
+      continue;
+    }
+    if (t.isExpressionStatement(n) && n.expression === prev) break;
+    if (t.isVariableDeclarator(n) && n.init === prev) {
+      return { ok: false, reason: 'aliased to another binding' };
+    }
+    if (t.isCallExpression(n) || t.isNewExpression(n)) {
+      return escapeSafe() ? { ok: true } : { ok: false, reason: 'parsed object (or an object-valued property) passed to a call' };
+    }
+    if (t.isReturnStatement(n) || t.isThrowStatement(n) || t.isSpreadElement(n) ||
+        t.isForOfStatement(n) || t.isForInStatement(n) || t.isArrayExpression(n) ||
+        t.isObjectProperty(n)) {
+      return escapeSafe() ? { ok: true } : { ok: false, reason: 'parsed object escapes by reference' };
+    }
+    return { ok: false, reason: `used in unsupported context (${n.type})` };
+  }
+  if (!p) return { ok: false, reason: 'no statement context' };
+  return { ok: true };
+}

package/src/passes/r3-try-catch-strip.js

@@ -0,0 +1,61 @@
+/**
+ * R3 try-catch-strip — RISKY, hot functions only.
+ *
+ * Removes `try { ... } catch {}` when the try body contains no calls (and the
+ * catch body is empty). The catch becomes dead weight: with no calls in the
+ * try body, the only throws left are engine-level pathological ones.
+ *
+ * Failure mode: a pathological engine-level throw now crashes the pack script
+ * instead of being swallowed.
+ *
+ * Bail conditions: finally present, catch body non-empty, try body contains
+ * CallExpression / NewExpression / AwaitExpression / YieldExpression /
+ * tagged templates / optional calls. Every application warns.
+ */
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import { walkSameFunction } from '../pass-utils.js';
+
+const _traverse = traverse.default || traverse;
+
+export const ID = 'try-catch-strip';
+export const CODE = 'R3';
+
+export default function tryCatchStrip(programPath, ctx) {
+  programPath.traverse({
+    TryStatement(path) {
+      const node = path.node;
+      const line = node.loc ? node.loc.start.line : 0;
+      const fnParent = path.getFunctionParent();
+      if (!fnParent || !ctx.isHot(fnParent.node)) return;
+      if (ctx.isDisabled(path, ID, CODE)) return;
+
+      if (node.finalizer) {
+        ctx.bail(line, CODE, 'finally present');
+        return;
+      }
+      if (!node.handler) return; // try/finally handled above
+      if (node.handler.body.body.length > 0) {
+        ctx.bail(line, CODE, 'catch body is not empty');
+        return;
+      }
+      let hasCall = false;
+      walkSameFunction(node.block, (n) => {
+        if (t.isCallExpression(n) || t.isNewExpression(n) || t.isTaggedTemplateExpression(n) ||
+            t.isOptionalCallExpression(n) || t.isAwaitExpression(n) || t.isYieldExpression(n)) {
+          hasCall = true;
+          return false;
+        }
+        return true;
+      });
+      if (hasCall) {
+        ctx.bail(line, CODE, 'try body contains calls');
+        return;
+      }
+      path.replaceWithMultiple(node.block.body);
+      ctx.applied(ID);
+      ctx.warn(line, CODE,
+        'try/catch removed in hot function — engine-level throws now propagate');
+    },
+  });
+}

package/src/passes/r4-getter-cache-cross-barrier.js

@@ -0,0 +1,29 @@
+/**
+ * R4 getter-cache-cross-barrier — RISKY.
+ *
+ * B1 (cache-getter-chains), but allowed to cross call and assignment barriers
+ * within one synchronous callback invocation. Await/yield remain barriers.
+ *
+ * Failure mode: if an intervening call moves or modifies the entity (teleport,
+ * damage, dimension change), cached values are stale — e.g. teleport then read
+ * cached `location`. Every hoisted chain emits a warning.
+ */
+import traverse from '@babel/traverse';
+import b1Impl from './b1-cache-getter-chains.js';
+
+const _traverse = traverse.default || traverse;
+
+export const ID = 'getter-cache-cross-barrier';
+export const CODE = 'R4';
+
+export default function getterCacheCrossBarrier(programPath, ctx) {
+  b1Impl(programPath, ctx, {
+    id: ID,
+    code: CODE,
+    crossBarriers: true,
+    onApply: (line, links) => {
+      ctx.warn(line, CODE,
+        `chain .${links} cached across call barriers — stale if an intervening call moves/modifies the entity`);
+    },
+  });
+}