optipack 0.0.0-stage → 1.0.1

package/src/passes/b2-closure-lift.js

@@ -0,0 +1,316 @@
+/**
+ * B2 closure-lift — balanced level.
+ *
+ * Arrow / function expressions created lexically inside hot functions are
+ * re-allocated on every tick. When they capture nothing, only module-level
+ * identifiers/globals, or only `const`-bound primitives (inlined as module
+ * consts), they are lifted to module scope and their creation site becomes a
+ * plain identifier reference.
+ *
+ * Cell capture: when an arrow captures a per-invocation local that is never
+ * reassigned, it can still be lifted by routing the capture through a
+ * module-level cell (`let __opCellN;`) assigned at the arrow's creation point.
+ * This is sound only when the arrow can never outlive the cell assignment:
+ *
+ *   - every reference of the arrow binding is a DIRECT synchronous call in the
+ *     enclosing function (callee position; never passed as a value, registered,
+ *     stored, or returned) — so no closure survives into a later invocation
+ *     where the cell holds a different value;
+ *   - the arrow's creation point is not lexically inside a loop (a shared cell
+ *     would be clobbered across iterations that each register/keep a closure);
+ *   - the enclosing function is sync and contains no await/yield (no
+ *     interleaving between the cell assignment and the call);
+ *   - the captured local is declared (and its declaration ends) before the
+ *     arrow's creation statement (no TDZ / `var` hoisting reads);
+ *   - the captured binding is never reassigned (its value at the assignment
+ *     point equals its value at every call point).
+ *
+ * Arrows that ESCAPE with live captures (e.g. `system.runInterval(() =>
+ * fn(player))` inside a handler that may run more than once) still bail: each
+ * registration needs its own capture, which a single cell cannot represent,
+ * and the enclosing function's invocation count is statically unprovable.
+ *
+ * Also bails: references to `this`, `arguments`, `super`, `new.target`.
+ * Hotness is preserved: a lifted function that was hot stays hot.
+ */
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import { walk, walkSameFunction } from '../pass-utils.js';
+
+const _traverse = traverse.default || traverse;
+
+export const ID = 'closure-lift';
+export const CODE = 'B2';
+
+function primitiveInitNode(node) {
+  if (!node) return null;
+  if (t.isStringLiteral(node) || t.isNumericLiteral(node) || t.isBooleanLiteral(node) || t.isNullLiteral(node)) return node;
+  if (t.isTemplateLiteral(node) && node.expressions.length === 0) return node;
+  if (t.isUnaryExpression(node) && (node.operator === '-' || node.operator === '+') && t.isNumericLiteral(node.argument)) return node;
+  return null;
+}
+
+function isProgramScope(binding) {
+  return !!(binding.scope && binding.scope.path && binding.scope.path.isProgram());
+}
+
+/** Is the node lexically inside the body (or per-iteration parts) of a loop? */
+function insideLoop(nodePath) {
+  for (let p = nodePath.parentPath; p; p = p.parentPath) {
+    const n = p.node;
+    if (t.isFunction(n) || t.isProgram(n)) return false;
+    if (t.isForStatement(n) || t.isWhileStatement(n) || t.isDoWhileStatement(n) ||
+        t.isForOfStatement(n) || t.isForInStatement(n)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** Does the enclosing function itself contain await or yield (same function only)? */
+function containsSuspension(fnPath) {
+  let found = false;
+  walkSameFunction(fnPath.node.body, (n) => {
+    if (t.isAwaitExpression(n) || t.isYieldExpression(n)) {
+      found = true;
+      return false;
+    }
+    if (t.isForOfStatement(n) && n.await) { found = true; return false; }
+    return true;
+  });
+  return found;
+}
+
+/**
+ * No-escape check for cell capture: every reference of the arrow's binding is
+ * the CALLEE of a call whose enclosing function is `ownerFnNode`. Returns
+ * { ok, reason }.
+ */
+function allUsesAreSyncCalls(binding, ownerFnNode) {
+  if (!binding) return { ok: false, reason: 'anonymous arrow' };
+  if (binding.constantViolations.length > 0) {
+    return { ok: false, reason: 'arrow binding is reassigned' };
+  }
+  const refs = binding.referencePaths;
+  if (refs.length === 0) return { ok: false, reason: 'arrow is never used' };
+  for (const ref of refs) {
+    const parent = ref.parent;
+    if (!(t.isCallExpression(parent) && parent.callee === ref.node)) {
+      return { ok: false, reason: 'arrow escapes as a value (registered, stored, or returned)' };
+    }
+    const callParent = ref.getFunctionParent();
+    if (!callParent || callParent.node !== ownerFnNode) {
+      return { ok: false, reason: 'arrow is called from a nested function' };
+    }
+  }
+  return { ok: true };
+}
+
+export default function closureLift(programPath, ctx) {
+  // Compute the insertion index after imports (or 0 when uses may precede it).
+  const body = programPath.node.body;
+  let lastImport = -1;
+  for (let i = 0; i < body.length; i++) {
+    if (t.isImportDeclaration(body[i])) lastImport = i;
+  }
+
+  const lifts = []; // { path, fnNode, liftName, cloned, capDecls, cellDecls, cellAssignments }
+
+  programPath.traverse({
+    'ArrowFunctionExpression|FunctionExpression'(path) {
+      const fn = path.node;
+      const fnParent = path.getFunctionParent();
+      if (!fnParent || !ctx.isHot(fnParent.node)) return;
+      if (fnParent.node === fn) return;
+      if (ctx.isDisabled(path, ID, CODE)) return;
+      if (lifts.some((l) => l.fnNode === fn)) return;
+
+      const fail = (reason) => {
+        ctx.bail(fn.loc ? fn.loc.start.line : 0, CODE, reason);
+      };
+
+      let bad = null;
+      walk(fn.body, (n) => {
+        if (bad) return false;
+        if (t.isThisExpression(n)) { bad = 'references this'; return false; }
+        if (t.isIdentifier(n) && n.name === 'arguments') { bad = 'references arguments'; return false; }
+        if (t.isSuper(n)) { bad = 'references super'; return false; }
+        if (t.isMetaProperty(n)) { bad = 'references new.target'; return false; }
+        return true;
+      });
+      if (bad) return fail(bad);
+
+      // Classify captures.
+      const captures = new Map(); // binding -> { mode: 'inline'|'cell', init?, refs: [] }
+      let bailReason = null;
+      path.traverse({
+        ReferencedIdentifier(refPath) {
+          if (bailReason) return;
+          const name = refPath.node.name;
+          const binding = refPath.scope.getBinding(name);
+          if (!binding) return; // global
+          if (binding.path === path || isDescendantPath(binding.path, path)) return;
+          if (isProgramScope(binding)) return; // module-level
+          if (binding.constantViolations.length > 0) {
+            bailReason = `captured local "${name}" is reassigned`;
+            return;
+          }
+          const decl = binding.path;
+          if (decl.isVariableDeclarator()) {
+            const prim = primitiveInitNode(decl.node.init);
+            if (prim) {
+              if (!captures.has(binding)) captures.set(binding, { mode: 'inline', init: prim, refs: [] });
+              captures.get(binding).refs.push(refPath);
+              return;
+            }
+          }
+          // Not an inline-able const primitive: candidate for cell capture.
+          if (!captures.has(binding)) captures.set(binding, { mode: 'cell', name, refs: [] });
+          captures.get(binding).refs.push(refPath);
+        },
+      });
+      if (bailReason) return fail(bailReason);
+
+      const needsCell = [...captures.values()].some((c) => c.mode === 'cell');
+      const stmtPath = nearestStatement(path);
+      if (needsCell) {
+        // Cell capture soundness preconditions.
+        if (insideLoop(path)) {
+          return fail('captures a live local and is created inside a loop (a shared cell would be clobbered)');
+        }
+        if (fnParent.node.async || fnParent.node.generator || containsSuspension(fnParent)) {
+          return fail('captures a live local inside an async/generator function (interleaving could change the cell)');
+        }
+        // The arrow binding: VariableDeclarator id, or AssignmentExpression lhs.
+        let binding = null;
+        if (path.parentPath.isVariableDeclarator() && t.isIdentifier(path.parentPath.node.id)) {
+          binding = path.parentPath.scope.getBinding(path.parentPath.node.id.name);
+        } else if (path.parentPath.isAssignmentExpression() && t.isIdentifier(path.parentPath.node.left)) {
+          binding = path.parentPath.scope.getBinding(path.parentPath.node.left.name);
+        }
+        const escape = allUsesAreSyncCalls(binding, fnParent.node);
+        if (!escape.ok) {
+          return fail(`captures a live local and ${escape.reason} — a lifted function could observe a newer cell value`);
+        }
+        // Captured locals must be declared, and their declarations finished,
+        // before the STATEMENT containing the arrow's creation (the cell
+        // assignment is inserted there — reading a not-yet-declared local
+        // would be a new TDZ/hoisting hazard).
+        if (!stmtPath) {
+          return fail('captures a live local but has no statement context');
+        }
+        const creationStmtStart = stmtPath.node.start ?? 0;
+        for (const [binding2, cap] of captures) {
+          if (cap.mode !== 'cell') continue;
+          const declEnd = binding2.path.node.end ?? 0;
+          if (declEnd >= creationStmtStart) {
+            return fail(`captured local "${cap.name}" is declared at or after the arrow's creation statement (TDZ/hoisting hazard)`);
+          }
+        }
+      }
+
+      // Plan the lift.
+      const capDecls = [];
+      const cellDecls = [];
+      for (const [, cap] of captures) {
+        if (cap.mode === 'inline') {
+          const capName = programPath.scope.generateUid('opCap');
+          capDecls.push({ name: capName, init: t.cloneNode(cap.init, true) });
+          for (const ref of cap.refs) {
+            if (ref.node && ref.node.type) ref.replaceWith(t.identifier(capName));
+          }
+        } else {
+          const cellName = programPath.scope.generateUid('opCell');
+          cap.cellName = cellName;
+          cellDecls.push(cellName);
+          for (const ref of cap.refs) {
+            if (ref.node && ref.node.type) ref.replaceWith(t.identifier(cellName));
+          }
+        }
+      }
+      const liftName = programPath.scope.generateUid('opLift');
+      const cloned = t.cloneNode(path.node, true);
+
+      // Cell assignments go immediately before the statement containing the
+      // arrow's creation, in the order the captures were classified. The
+      // statement path was already computed during the bail checks.
+      const cellAssignments = [];
+      if (needsCell) {
+        for (const [, cap] of captures) {
+          if (cap.mode !== 'cell') continue;
+          cellAssignments.push(t.expressionStatement(
+            t.assignmentExpression('=', t.identifier(cap.cellName), t.identifier(cap.name))
+          ));
+        }
+      }
+      lifts.push({ path, fnNode: fn, liftName, cloned, capDecls, cellDecls, cellAssignments, stmtPath });
+      if (ctx.hot) ctx.hot.copyHotness(fn, cloned);
+    },
+  });
+
+  if (lifts.length === 0) return;
+
+  // Sort by source position for deterministic insertion.
+  lifts.sort((a, b) => (a.fnNode.start || 0) - (b.fnNode.start || 0));
+
+  // Do any lift uses precede the end of the import block?
+  const importBoundary = lastImport >= 0 ? (body[lastImport].end || 0) : -1;
+  const anyBefore = lifts.some((l) => (l.fnNode.start || Infinity) < importBoundary);
+
+  const newStmts = [];
+  for (const l of lifts) {
+    for (const cap of l.capDecls) {
+      newStmts.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier(cap.name), cap.init),
+      ]));
+    }
+    for (const cellName of l.cellDecls) {
+      newStmts.push(t.variableDeclaration('let', [t.variableDeclarator(t.identifier(cellName))]));
+    }
+    newStmts.push(t.variableDeclaration('const', [
+      t.variableDeclarator(t.identifier(l.liftName), l.cloned),
+    ]));
+  }
+
+  const insertIdx = anyBefore ? 0 : lastImport + 1;
+  body.splice(insertIdx, 0, ...newStmts);
+
+  // Insert cell assignments grouped per statement (preserving lift order).
+  const byStatement = new Map();
+  for (const l of lifts) {
+    if (l.cellAssignments.length === 0 || !l.stmtPath) continue;
+    const key = l.stmtPath.node;
+    if (!byStatement.has(key)) byStatement.set(key, { stmtPath: l.stmtPath, stmts: [] });
+    byStatement.get(key).stmts.push(...l.cellAssignments);
+  }
+  for (const [, group] of byStatement) {
+    try {
+      group.stmtPath.insertBefore(group.stmts);
+    } catch {
+      // Statement not in a list position (e.g. an if consequent): wrap.
+      const node = group.stmtPath.node;
+      group.stmtPath.replaceWith(t.blockStatement([...group.stmts, node]));
+    }
+  }
+
+  for (const l of lifts) {
+    if (ctx.isDisabled(l.path, ID, CODE)) continue;
+    l.path.replaceWith(t.identifier(l.liftName));
+    ctx.applied(ID);
+  }
+}
+
+function nearestStatement(path) {
+  let p = path;
+  while (p && !p.isStatement()) p = p.parentPath;
+  return p;
+}
+
+function isDescendantPath(bindingPath, fnPath) {
+  let p = bindingPath;
+  while (p) {
+    if (p === fnPath) return true;
+    p = p.parentPath;
+  }
+  return false;
+}

package/src/passes/b3-string-build.js

@@ -0,0 +1,167 @@
+/**
+ * B3 string-build — balanced level.
+ *
+ * `s += x` accumulated inside a loop in a hot function becomes
+ * `parts.push("" + x)` with a single `s = parts.join("")` after the loop.
+ *
+ * Why: QuickJS strings are immutable flat buffers, so `+=` over long loops is
+ * O(n^2) copying. Array parts + one join is O(n).
+ *
+ * Preconditions (else bail):
+ *  - `s` is a `let` string initialized to "" and only ever written by the
+ *    `+=`/`s = s + x` statements inside ONE loop (or the initializer)
+ *  - `s` is never read inside the loop (including from nested closures)
+ *  - writes live in the hot function itself (not a nested closure)
+ *  - `s = x + s` (prepend) is not used
+ *
+ * `"" + x` preserves exact ToString semantics (including null -> "null",
+ * undefined -> "undefined", symbol throws) at the same evaluation point.
+ */
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import { walk } from '../pass-utils.js';
+
+const _traverse = traverse.default || traverse;
+
+export const ID = 'string-build';
+export const CODE = 'B3';
+
+export default function stringBuild(programPath, ctx) {
+  programPath.traverse({
+    VariableDeclaration(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;
+
+      const fail = (reason) => ctx.bail(line, CODE, reason);
+
+      if (node.kind !== 'let' || node.declarations.length !== 1) return;
+      const declarator = node.declarations[0];
+      if (!t.isIdentifier(declarator.id)) return;
+      if (!declarator.init || !t.isStringLiteral(declarator.init) || declarator.init.value !== '') return;
+
+      const name = declarator.id.name;
+      const binding = path.scope.getBinding(name);
+      if (!binding) return;
+
+      // All constant violations must be += or `s = s + x` inside ONE loop.
+      if (binding.constantViolations.length === 0) return;
+      let loopNode = null;
+      const writes = [];
+      for (const viol of binding.constantViolations) {
+        if (!viol.isAssignmentExpression()) return fail('non-assignment write to accumulator');
+        const vn = viol.node;
+        if (vn.operator === '+=') {
+          if (!t.isIdentifier(vn.left) || vn.left.name !== name) return fail('unexpected assignment shape');
+          writes.push({ node: vn, value: vn.right, violPath: viol });
+        } else if (vn.operator === '=') {
+          if (!t.isIdentifier(vn.left) || vn.left.name !== name) return fail('unexpected assignment shape');
+          const r = vn.right;
+          if (t.isBinaryExpression(r) && r.operator === '+' && t.isIdentifier(r.left) && r.left.name === name) {
+            writes.push({ node: vn, value: r.right, violPath: viol });
+          } else {
+            return fail('accumulator reassigned (not an append)');
+          }
+        } else {
+          return fail('unexpected assignment operator');
+        }
+        // Must live inside one loop, in the hot function itself.
+        const violParent = viol.parentPath ? viol.parentPath : null;
+        let l = viol;
+        while (l && !l.isProgram()) {
+          if (l.isForStatement() || l.isWhileStatement() || l.isDoWhileStatement() ||
+              l.isForOfStatement() || l.isForInStatement()) {
+            if (!loopNode) loopNode = l.node;
+            else if (loopNode !== l.node) return fail('writes span multiple loops');
+            break;
+          }
+          if (l.isFunctionExpression() || l.isArrowFunctionExpression()) {
+            return fail('accumulator written inside a nested closure');
+          }
+          l = l.parentPath;
+        }
+        if (!loopNode) return fail('accumulator written outside a loop');
+      }
+
+      // No reads of `s` inside the loop other than write targets and the
+      // `s` operand of a `s = s + x` append.
+      const appendOperands = new Set();
+      for (const w of writes) {
+        if (t.isBinaryExpression(w.value) && w.value.operator === '+' && t.isIdentifier(w.value.left) && w.value.left.name === name) {
+          appendOperands.add(w.value.left);
+        }
+      }
+      const inLoop = (n) => loopNode.start <= n.start && n.end <= loopNode.end;
+      for (const ref of binding.referencePaths) {
+        const n = ref.node;
+        if (!n || !inLoop(n)) continue;
+        const parent = ref.parent;
+        const isWriteTarget = t.isAssignmentExpression(parent) && parent.left === n;
+        if (!isWriteTarget && !appendOperands.has(n)) return fail('accumulator read inside the loop');
+      }
+      // `s += s` shape: right side reading s inside the loop.
+      for (const w of writes) {
+        let readsSelf = false;
+        walk(w.value, (n) => {
+          if (t.isIdentifier(n) && n.name === name) readsSelf = true;
+          return true;
+        });
+        if (readsSelf) return fail('accumulator reads itself in the append expression');
+      }
+
+      // The loop must be in the same function as the declaration; the
+      // violation scan above already established containment.
+
+      // ---- transform
+      const partsName = path.scope.generateUid('opParts');
+      const partsDecl = t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier(partsName), t.arrayExpression([])),
+      ]);
+      const joinStmt = t.expressionStatement(
+        t.assignmentExpression('=', t.identifier(name),
+          t.callExpression(t.memberExpression(t.identifier(partsName), t.identifier('join')), [t.stringLiteral('')]))
+      );
+
+      for (const w of writes) {
+        if (!w.violPath.parentPath || !w.violPath.parentPath.isExpressionStatement()) {
+          return fail('accumulator append is not a standalone statement');
+        }
+      }
+      for (const w of writes) {
+        const push = t.expressionStatement(
+          t.callExpression(
+            t.memberExpression(t.identifier(partsName), t.identifier('push')),
+            [t.binaryExpression('+', t.stringLiteral(''), w.value)]
+          )
+        );
+        w.violPath.replaceWith(push);
+      }
+
+      // Insert decl before the loop and join after it.
+      const loopPath = findLoopPath(programPath, loopNode);
+      if (!loopPath) return fail('internal: loop path not found');
+      const parent = loopPath.parentPath;
+      const inList = parent && (parent.isArrayExpression() || parent.isBlockStatement() ||
+        parent.isSwitchCase() || parent.isProgram());
+      if (inList) {
+        loopPath.insertBefore(partsDecl);
+        loopPath.insertAfter(joinStmt);
+      } else {
+        loopPath.replaceWith(t.blockStatement([partsDecl, loopPath.node, joinStmt]));
+      }
+      ctx.applied(ID);
+    },
+  });
+}
+
+function findLoopPath(programPath, loopNode) {
+  let found = null;
+  programPath.traverse({
+    'ForStatement|WhileStatement|DoWhileStatement|ForOfStatement|ForInStatement'(p) {
+      if (p.node === loopNode && !found) { found = p; p.stop(); }
+    },
+  });
+  return found;
+}

package/src/passes/b4-dynprop-hoist.js

@@ -0,0 +1,177 @@
+/**
+ * B4 dynprop-hoist — balanced level.
+ *
+ * `X.getDynamicProperty("k")` with a constant key, read inside a loop in a hot
+ * function, is hoisted above the loop when the loop is barrier-free apart from
+ * the reads themselves (no other calls, no property writes, no await/yield,
+ * no delete) and the receiver is never reassigned inside the loop.
+ *
+ * Reads are collected from unconditional top-level body statements only.
+ * Never cached across tick invocations at this level — that is R1 territory.
+ */
+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 = 'dynprop-hoist';
+export const CODE = 'B4';
+
+const LOOP_TYPES = ['ForStatement', 'WhileStatement', 'DoWhileStatement'];
+
+/** Replace oldNode with newNode anywhere in the tree rooted at rootNode. */
+function replaceIn(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' || key === '__opParent') 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;
+}
+
+export default function dynpropHoist(programPath, ctx) {
+  programPath.traverse({
+    [LOOP_TYPES.join('|')](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;
+
+      const fail = (reason) => ctx.bail(line, CODE, reason);
+
+      // ---- barrier scan: no calls other than getDynamicProperty reads,
+      // no await/yield, no property writes, no delete.
+      let hasOtherCall = false;
+      let hasAwaitYield = false;
+      let hasPropWrite = false;
+      const scan = (n) => {
+        walkSameFunction(n, (m) => {
+          if (t.isFunctionExpression(m) || t.isArrowFunctionExpression(m)) return false;
+          if (t.isCallExpression(m)) {
+            const isDynPropRead = t.isMemberExpression(m.callee) && !m.callee.computed &&
+              t.isIdentifier(m.callee.property) && m.callee.property.name === 'getDynamicProperty' &&
+              m.arguments.length === 1 && t.isStringLiteral(m.arguments[0]) &&
+              (t.isIdentifier(m.callee.object) || t.isThisExpression(m.callee.object));
+            if (!isDynPropRead) { hasOtherCall = true; return false; }
+            return true;
+          }
+          if (t.isNewExpression(m) || t.isTaggedTemplateExpression(m) || t.isOptionalCallExpression(m)) {
+            hasOtherCall = true;
+            return false;
+          }
+          if (t.isAwaitExpression(m) || t.isYieldExpression(m)) { hasAwaitYield = true; return false; }
+          if (t.isAssignmentExpression(m)) {
+            if (t.isMemberExpression(m.left)) { hasPropWrite = true; return false; }
+            return true;
+          }
+          if (t.isUpdateExpression(m)) {
+            if (t.isMemberExpression(m.argument)) { hasPropWrite = true; return false; }
+            return true;
+          }
+          if (t.isUnaryExpression(m) && m.operator === 'delete') { hasPropWrite = true; return false; }
+          return true;
+        });
+      };
+      walkSameFunction(node.body, scan);
+      if (node.type === 'ForStatement') {
+        if (node.test) scan(node.test);
+        if (node.update) scan(node.update);
+      }
+      if (hasPropWrite) return fail('loop contains property writes');
+      if (hasAwaitYield) return fail('loop contains await/yield');
+      if (hasOtherCall) return fail('loop contains calls other than getDynamicProperty reads');
+
+      // ---- collect reads from unconditional top-level body statements
+      const reads = []; // { node, stmt, receiverName, isThis, key }
+      const collect = (stmt) => {
+        walkSameFunction(stmt, (m) => {
+          if (t.isFunctionExpression(m) || t.isArrowFunctionExpression(m)) return false;
+          if (t.isCallExpression(m) && t.isMemberExpression(m.callee) && !m.callee.computed &&
+              t.isIdentifier(m.callee.property) && m.callee.property.name === 'getDynamicProperty' &&
+              m.arguments.length === 1 && t.isStringLiteral(m.arguments[0])) {
+            const obj = m.callee.object;
+            if (t.isIdentifier(obj)) {
+              reads.push({ node: m, stmt, receiverName: obj.name, isThis: false, key: m.arguments[0].value });
+            } else if (t.isThisExpression(obj)) {
+              reads.push({ node: m, stmt, receiverName: null, isThis: true, key: m.arguments[0].value });
+            }
+          }
+          return true;
+        });
+      };
+      const bodyIsBlock = t.isBlockStatement(node.body);
+      const topLevel = bodyIsBlock ? node.body.body : [node.body];
+      for (const stmt of topLevel) collect(stmt);
+      if (reads.length === 0) return;
+
+      // ---- receiver invariance inside the loop
+      const loopRange = { start: node.start, end: node.end };
+      for (const r of reads) {
+        if (r.isThis) continue;
+        const binding = path.scope.getBinding(r.receiverName);
+        if (!binding) continue;
+        for (const viol of binding.constantViolations) {
+          const vn = viol.node;
+          if (vn && vn.start !== undefined && vn.start >= loopRange.start && vn.end <= loopRange.end) {
+            return fail(`receiver "${r.receiverName}" reassigned inside the loop`);
+          }
+        }
+      }
+
+      // ---- group by receiver identity + key
+      const bindingId = (name) => {
+        const binding = path.scope.getBinding(name);
+        return binding ? `b:${bindingScopeId(binding)}` : 'global:' + name;
+      };
+      const groups = new Map();
+      for (const r of reads) {
+        const key = (r.isThis ? '@this' : bindingId(r.receiverName)) + '#' + r.key;
+        if (!groups.has(key)) groups.set(key, { receiverName: r.receiverName, isThis: r.isThis, key: r.key, uses: [] });
+        groups.get(key).uses.push(r);
+      }
+
+      // ---- hoist + rewrite
+      const decls = [];
+      for (const [, g] of groups) {
+        const name = path.scope.generateUid('opDP');
+        const recv = g.isThis ? t.thisExpression() : t.identifier(g.receiverName);
+        const call = t.callExpression(
+          t.memberExpression(recv, t.identifier('getDynamicProperty')),
+          [t.stringLiteral(g.key)]
+        );
+        decls.push(t.variableDeclaration('const', [t.variableDeclarator(t.identifier(name), call)]));
+        for (const u of g.uses) {
+          replaceIn(u.stmt, u.node, t.identifier(name));
+        }
+      }
+      const insertTarget = path.parentPath && path.parentPath.isLabeledStatement() ? path.parentPath : path;
+      insertTarget.insertBefore(decls);
+      ctx.applied(ID);
+    },
+  });
+}
+
+let scopeCounter = 0;
+const scopeIds = new WeakMap();
+function bindingScopeId(binding) {
+  let id = scopeIds.get(binding);
+  if (id === undefined) {
+    id = ++scopeCounter;
+    scopeIds.set(binding, id);
+  }
+  return id;
+}