optipack 0.0.0-stage → 1.0.0

package/test/json-fold-bail/config.json

@@ -0,0 +1 @@
+{"level": "risky"}

package/test/json-fold-bail/expected.js

@@ -0,0 +1,10 @@
+// R2 bail: JSON.parse result is mutated and passed around.
+import { world } from '@minecraft/server';
+const CFG = JSON.parse('{"n":1}');
+export function passAround() {
+  return handle(CFG);
+}
+function handle(c) {
+  return c.n;
+}
+world.sendMessage(passAround());

package/test/json-fold-bail/expects.json

@@ -0,0 +1,5 @@
+{
+    "transforms":  {
+                       "json-fold":  0
+                   }
+}

package/test/json-fold-bail/input.js

@@ -0,0 +1,14 @@
+// R2 bail: JSON.parse result is mutated and passed around.
+import { world } from '@minecraft/server';
+
+const CFG = JSON.parse('{"n":1}');
+
+export function passAround() {
+  return handle(CFG);
+}
+
+function handle(c) {
+  return c.n;
+}
+
+world.sendMessage(passAround());

package/test/loader-hooks.mjs

@@ -0,0 +1,38 @@
+/**
+ * Node module loader hooks for differential testing.
+ *
+ * - `@minecraft/server` resolves to the mock module (single instance; the
+ *   recorder is passed via globalThis.__opkRecorder).
+ * - Pack files are loaded with a `?opkv=<variant>` query so the original and
+ *   optimized variants get separate ESM cache entries; the query is stripped
+ *   when reading from disk and propagated to relative imports.
+ */
+import path from 'node:path';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+
+const MOCK_URL = pathToFileURL(
+  path.join(path.dirname(fileURLToPath(import.meta.url)), 'mock', '@minecraft', 'server.mjs')
+).href;
+
+export async function resolve(specifier, context, nextResolve) {
+  if (specifier === '@minecraft/server') {
+    return { url: MOCK_URL, shortCircuit: true };
+  }
+  const res = await nextResolve(specifier, context);
+  const parentURL = context.parentURL || '';
+  if (parentURL.includes('opkv=') && res.url.startsWith('file:') && !res.url.includes('opkv=')) {
+    const q = new URL(parentURL).search;
+    return { ...res, url: res.url + q, shortCircuit: true };
+  }
+  return res;
+}
+
+export async function load(url, context, nextLoad) {
+  const u = new URL(url);
+  if (u.protocol === 'file:' && u.search) {
+    const clean = pathToFileURL(fileURLToPath(u)).href;
+    const r = await nextLoad(clean, context);
+    return { format: r.format || 'module', source: r.source, shortCircuit: true };
+  }
+  return nextLoad(url, context);
+}

package/test/mock/@minecraft/server.mjs

@@ -0,0 +1,274 @@
+/**
+ * Mock @minecraft/server for differential testing.
+ *
+ * Effect-recorder contract: only MUTATING calls and registrations are recorded
+ * as effects. Pure reads return scripted sequences and are intentionally not
+ * recorded — transforms may legitimately eliminate reads, that is the point.
+ *
+ * The active recorder is read from globalThis.__opkRecorder at call time, so a
+ * single mock module instance serves both the original and the optimized
+ * variant of a script.
+ */
+
+const rec = () => globalThis.__opkRecorder;
+
+function scriptedRead(key, fallback) {
+  const r = rec();
+  if (!r) return fallback;
+  return r.scriptedRead(key, fallback);
+}
+
+function effect(call, args) {
+  const r = rec();
+  if (r) r.effect(call, args === undefined ? null : args);
+}
+
+function serialize(v) {
+  if (v === null) return null;
+  const t = typeof v;
+  if (t === 'string' || t === 'number' || t === 'boolean' || t === 'undefined') return v;
+  if (v instanceof Entity) return { __entity: v.id };
+  if (v instanceof Dimension) return { __dimension: v.id };
+  if (Array.isArray(v)) return v.map(serialize);
+  if (t === 'object') {
+    const out = {};
+    for (const k of Object.keys(v)) out[k] = serialize(v[k]);
+    return out;
+  }
+  return String(v);
+}
+
+class Dimension {
+  constructor(id) {
+    this.id = id;
+  }
+  getEntities(options) {
+    effect('dimension.getEntities', { dimension: this.id, options: serialize(options) });
+    return scriptedRead(`entities:${this.id}`, []);
+  }
+  getPlayers() {
+    effect('dimension.getPlayers', { dimension: this.id });
+    return scriptedRead(`players:${this.id}`, []);
+  }
+  spawnEntity(type, location) {
+    effect('dimension.spawnEntity', { dimension: this.id, type, location: serialize(location) });
+    return scriptedRead(`spawn:${this.id}:${type}`, null);
+  }
+  spawnParticle(effectName, location, molangVariables) {
+    effect('dimension.spawnParticle', { dimension: this.id, effectName, location: serialize(location), molang: serialize(molangVariables) });
+  }
+  runCommand(commandString) {
+    effect('dimension.runCommand', { dimension: this.id, command: commandString });
+  }
+}
+
+class Entity {
+  constructor(id, typeId, dimension) {
+    this._id = id;
+    this.typeId = typeId;
+    this._dimension = dimension;
+  }
+  get id() {
+    return this._id;
+  }
+  get name() {
+    return scriptedRead(`name:${this._id}`, 'player' + this._id);
+  }
+  get location() {
+    return scriptedRead(`location:${this._id}`, { x: 0, y: 0, z: 0 });
+  }
+  get dimension() {
+    return this._dimension;
+  }
+  getComponent(componentId) {
+    return scriptedRead(`component:${this._id}:${componentId}`, undefined);
+  }
+  getComponents() {
+    effect('entity.getComponents', { entity: this._id });
+    return [];
+  }
+  getDynamicProperty(identifier) {
+    return scriptedRead(`dp:${this._id}:${identifier}`, undefined);
+  }
+  setDynamicProperty(identifier, value) {
+    effect('entity.setDynamicProperty', { entity: this._id, key: identifier, value: serialize(value) });
+  }
+  sendMessage(message) {
+    effect('entity.sendMessage', { entity: this._id, message: serialize(message) });
+  }
+  runCommand(commandString) {
+    effect('entity.runCommand', { entity: this._id, command: commandString });
+  }
+  teleport(location, teleportOptions) {
+    effect('entity.teleport', { entity: this._id, location: serialize(location), options: serialize(teleportOptions) });
+  }
+  applyDamage(amount, options) {
+    effect('entity.applyDamage', { entity: this._id, amount, options: serialize(options) });
+    return scriptedRead(`damage:${this._id}`, true);
+  }
+  kill() {
+    effect('entity.kill', { entity: this._id });
+  }
+  addTag(tag) {
+    effect('entity.addTag', { entity: this._id, tag });
+    return true;
+  }
+  removeTag(tag) {
+    effect('entity.removeTag', { entity: this._id, tag });
+    return true;
+  }
+  hasTag(tag) {
+    return scriptedRead(`tag:${this._id}:${tag}`, false);
+  }
+  playAnimation(animationName, options) {
+    effect('entity.playAnimation', { entity: this._id, animationName, options: serialize(options) });
+  }
+  triggerEvent(eventName) {
+    effect('entity.triggerEvent', { entity: this._id, eventName });
+  }
+  getRotation() {
+    return scriptedRead(`rotation:${this._id}`, { x: 0, y: 0 });
+  }
+  getVelocity() {
+    return scriptedRead(`velocity:${this._id}`, { x: 0, y: 0, z: 0 });
+  }
+}
+
+function makeEvent(fullName) {
+  return {
+    subscribe(callback, options) {
+      effect('subscribe', { event: fullName, options: serialize(options) });
+      const r = rec();
+      if (r) r.addHandler(fullName, callback);
+    },
+    unsubscribe(callback) {
+      effect('unsubscribe', { event: fullName });
+      const r = rec();
+      if (r) r.removeHandler(fullName, callback);
+    },
+  };
+}
+
+const worldAfterEvents = {
+  worldLoad: makeEvent('world.afterEvents.worldLoad'),
+  worldInitialize: makeEvent('world.afterEvents.worldInitialize'),
+  playerSpawn: makeEvent('world.afterEvents.playerSpawn'),
+  playerJoin: makeEvent('world.afterEvents.playerJoin'),
+  playerLeave: makeEvent('world.afterEvents.playerLeave'),
+  entityDie: makeEvent('world.afterEvents.entityDie'),
+  entityHurt: makeEvent('world.afterEvents.entityHurt'),
+  itemUse: makeEvent('world.afterEvents.itemUse'),
+  chatSend: makeEvent('world.afterEvents.chatSend'),
+};
+const worldBeforeEvents = {
+  worldLoad: makeEvent('world.beforeEvents.worldLoad'),
+  playerInteractWithBlock: makeEvent('world.beforeEvents.playerInteractWithBlock'),
+  playerInteractWithEntity: makeEvent('world.beforeEvents.playerInteractWithEntity'),
+  itemUse: makeEvent('world.beforeEvents.itemUse'),
+  chatSend: makeEvent('world.beforeEvents.chatSend'),
+};
+
+function currentPlayers() {
+  const r = rec();
+  if (!r) return [];
+  ensurePlayers(r);
+  return r._players;
+}
+
+function ensurePlayers(r) {
+  if (r._players) return r._players;
+  const specs = (r.state && r.state.players) || [];
+  r._players = specs.map((s) => new Entity(s.id, s.typeId || 'minecraft:player', new Dimension(s.dimension || 'minecraft:overworld')));
+  return r._players;
+}
+
+// The differential driver hydrates event payloads via this hook.
+if (typeof globalThis !== 'undefined') {
+  globalThis.__opkEnsurePlayers = ensurePlayers;
+}
+
+export const world = {
+  get afterEvents() {
+    return worldAfterEvents;
+  },
+  get beforeEvents() {
+    return worldBeforeEvents;
+  },
+  getAllPlayers() {
+    effect('world.getAllPlayers', null);
+    return currentPlayers();
+  },
+  getPlayers() {
+    effect('world.getPlayers', null);
+    return currentPlayers();
+  },
+  getDynamicProperty(identifier) {
+    return scriptedRead(`world.dp:${identifier}`, undefined);
+  },
+  setDynamicProperty(identifier, value) {
+    effect('world.setDynamicProperty', { key: identifier, value: serialize(value) });
+  },
+  sendMessage(message) {
+    effect('world.sendMessage', { message: serialize(message) });
+  },
+  getEntity(identifier) {
+    effect('world.getEntity', { id: identifier });
+    return scriptedRead(`world.entity:${identifier}`, undefined);
+  },
+  getDimension(dimensionId) {
+    effect('world.getDimension', { id: dimensionId });
+    return new Dimension(dimensionId);
+  },
+  playSound(soundId, options) {
+    effect('world.playSound', { soundId, options: serialize(options) });
+  },
+};
+
+const systemBeforeEvents = {
+  tick: makeEvent('system.beforeEvents.tick'),
+  watchdogTerminate: makeEvent('system.beforeEvents.watchdogTerminate'),
+};
+const systemAfterEvents = {
+  tick: makeEvent('system.afterEvents.tick'),
+  watchdogTerminate: makeEvent('system.afterEvents.watchdogTerminate'),
+};
+
+export const system = {
+  get beforeEvents() {
+    return systemBeforeEvents;
+  },
+  get afterEvents() {
+    return systemAfterEvents;
+  },
+  runInterval(callback, tickInterval) {
+    const interval = tickInterval === undefined ? 1 : tickInterval;
+    effect('system.runInterval', { interval });
+    const r = rec();
+    return r ? r.addInterval(callback, interval) : -1;
+  },
+  runTimeout(callback, timeoutTicks) {
+    const delay = timeoutTicks === undefined ? 1 : timeoutTicks;
+    effect('system.runTimeout', { delay });
+    const r = rec();
+    return r ? r.addTimeout(callback, delay) : -1;
+  },
+  run(callback) {
+    effect('system.run', null);
+    const r = rec();
+    return r ? r.addTimeout(callback, 1) : -1;
+  },
+  runJob(generator) {
+    effect('system.runJob', null);
+    const r = rec();
+    if (r) r.addJob(generator);
+    return { cancel() { effect('system.clearRun', { id: 'job' }); } };
+  },
+  clearRun(runId) {
+    effect('system.clearRun', { id: serialize(runId) });
+  },
+};
+
+export { Entity, Dimension };
+export const TicksPerSecond = 20;
+export const GameMode = { survival: 'survival', creative: 'creative', adventure: 'adventure' };
+export default { world, system, Entity, Dimension, TicksPerSecond, GameMode };

package/test/null-chain-flatten/expected.js

@@ -0,0 +1,22 @@
+// B5: optional chains flattened after proven guards.
+import { world, system } from '@minecraft/server';
+function onTick(player) {
+  if (!player) return;
+  world.sendMessage('n=' + player.name);
+  const loc = player?.location;
+  world.sendMessage('y=' + (loc === undefined ? -1 : loc.y));
+
+  // Barrier (call) ends the guard window: `player?.name` below stays.
+  world.sendMessage('mid');
+  world.sendMessage('after=' + player?.name);
+}
+
+// Guard on an undefined-strictness check.
+function withEqNull(ev) {
+  if (ev.player == null) return;
+  world.sendMessage('eq=' + ev.player?.name);
+}
+system.runInterval(() => onTick(world.getAllPlayers()[0]), 20);
+system.runInterval(() => withEqNull({
+  player: null
+}), 20);

package/test/null-chain-flatten/expects.json

@@ -0,0 +1,5 @@
+{
+    "transforms":  {
+                       "null-chain-flatten":  1
+                   }
+}

package/test/null-chain-flatten/input.js

@@ -0,0 +1,22 @@
+// B5: optional chains flattened after proven guards.
+import { world, system } from '@minecraft/server';
+
+function onTick(player) {
+  if (!player) return;
+  world.sendMessage('n=' + player?.name);
+  const loc = player?.location;
+  world.sendMessage('y=' + (loc === undefined ? -1 : loc.y));
+
+  // Barrier (call) ends the guard window: `player?.name` below stays.
+  world.sendMessage('mid');
+  world.sendMessage('after=' + player?.name);
+}
+
+// Guard on an undefined-strictness check.
+function withEqNull(ev) {
+  if (ev.player == null) return;
+  world.sendMessage('eq=' + ev.player?.name);
+}
+
+system.runInterval(() => onTick(world.getAllPlayers()[0]), 20);
+system.runInterval(() => withEqNull({ player: null }), 20);

package/test/null-chain-flatten/scenario.json

@@ -0,0 +1,24 @@
+{
+    "reads":  {
+                  "name:p1":  [
+                                  "Alice"
+                              ]
+              },
+    "entry":  "scripts/input.js",
+    "steps":  [
+                  {
+                      "n":  5,
+                      "op":  "tick"
+                  }
+              ],
+    "state":  {
+                  "players":  [
+                                  {
+                                      "id":  "p1"
+                                  },
+                                  {
+                                      "id":  "p2"
+                                  }
+                              ]
+              }
+}

package/test/string-build/expected.js

@@ -0,0 +1,29 @@
+// B3: string accumulation in a hot loop -> parts + join.
+import { world, system } from '@minecraft/server';
+function onTick(players) {
+  let summary = '';
+  const _opParts = [];
+  for (let i = 0; i < players.length; i++) {
+    _opParts.push("" + (players[i].name + ';'));
+  }
+  summary = _opParts.join("");
+  world.sendMessage(summary);
+}
+
+// Written outside a loop: bails.
+export function notALoop(players) {
+  let s = '';
+  s += 'x';
+  world.sendMessage(s);
+}
+
+// Read inside the loop: bails.
+export function readInside(players) {
+  let s = '';
+  for (let i = 0; i < players.length; i++) {
+    s += players[i].name;
+    world.sendMessage(s);
+  }
+  world.sendMessage(s);
+}
+system.runInterval(() => onTick(world.getAllPlayers()), 20);

package/test/string-build/expects.json

@@ -0,0 +1,5 @@
+{
+    "transforms":  {
+                       "string-build":  1
+                   }
+}

package/test/string-build/input.js

@@ -0,0 +1,29 @@
+// B3: string accumulation in a hot loop -> parts + join.
+import { world, system } from '@minecraft/server';
+
+function onTick(players) {
+  let summary = '';
+  for (let i = 0; i < players.length; i++) {
+    summary += players[i].name + ';';
+  }
+  world.sendMessage(summary);
+}
+
+// Written outside a loop: bails.
+export function notALoop(players) {
+  let s = '';
+  s += 'x';
+  world.sendMessage(s);
+}
+
+// Read inside the loop: bails.
+export function readInside(players) {
+  let s = '';
+  for (let i = 0; i < players.length; i++) {
+    s += players[i].name;
+    world.sendMessage(s);
+  }
+  world.sendMessage(s);
+}
+
+system.runInterval(() => onTick(world.getAllPlayers()), 20);

package/test/string-build/scenario.json

@@ -0,0 +1,27 @@
+{
+    "reads":  {
+                  "name:p1":  [
+                                  "Alice"
+                              ],
+                  "name:p2":  [
+                                  "Bob"
+                              ]
+              },
+    "entry":  "scripts/input.js",
+    "steps":  [
+                  {
+                      "n":  5,
+                      "op":  "tick"
+                  }
+              ],
+    "state":  {
+                  "players":  [
+                                  {
+                                      "id":  "p1"
+                                  },
+                                  {
+                                      "id":  "p2"
+                                  }
+                              ]
+              }
+}

package/test/string-build-bail/expected.js

@@ -0,0 +1,10 @@
+// B3 bails: prepend pattern and accumulator read inside the loop.
+import { world, system } from '@minecraft/server';
+function prepend(players) {
+  let s = '';
+  for (let i = 0; i < players.length; i++) {
+    s = players[i].name + s;
+  }
+  world.sendMessage(s);
+}
+system.runInterval(() => prepend(world.getAllPlayers()), 20);

package/test/string-build-bail/input.js

@@ -0,0 +1,21 @@
+// B3 bails: prepend pattern and accumulator read inside the loop.
+import { world, system } from '@minecraft/server';
+
+function prepend(players) {
+  let s = '';
+  for (let i = 0; i < players.length; i++) {
+    s = players[i].name + s;
+  }
+  world.sendMessage(s);
+}
+
+function readInside(players) {
+  let s = '';
+  for (let i = 0; i < players.length; i++) {
+    s += players[i].name;
+    world.sendMessage(s.length);
+  }
+  world.sendMessage(s);
+}
+
+system.runInterval(() => prepend(world.getAllPlayers()), 20);

package/test/transforms.test.mjs

@@ -0,0 +1,43 @@
+/**
+ * Per-transform unit tests: every test/<transformId>/ fixture runs through the
+ * full pipeline, compares exact output against expected.js (or expects the
+ * input unchanged), asserts report expectations, and — when scenario.json is
+ * present — checks effects-equivalence between the original and optimized
+ * code against the mock @minecraft/server.
+ */
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import fs from 'node:fs';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+const { runFixtureDir, fixtureDirs } = await import('./harness/fixture.js');
+const { differentialCheck } = await import('./harness/setup.js');
+
+const dirs = fixtureDirs(here);
+
+for (const dir of dirs) {
+  const name = path.basename(dir);
+  test(`fixture: ${name}`, async () => {
+    const result = await runFixtureDir(dir);
+    assert.ok(result.output.length > 0);
+    // Round-trip parse is enforced inside the pipeline; double-check here.
+    const { parseSource } = await import('../src/pipeline.js');
+    parseSource(name, result.output);
+  });
+
+  if (fs.existsSync(path.join(dir, 'scenario.json'))) {
+    test(`differential: ${name}`, async () => {
+      const scenario = JSON.parse(fs.readFileSync(path.join(dir, 'scenario.json'), 'utf8'));
+      const configRaw = fs.existsSync(path.join(dir, 'config.json'))
+        ? JSON.parse(fs.readFileSync(path.join(dir, 'config.json'), 'utf8').replace(/^\uFEFF/, ''))
+        : { level: 'balanced' };
+      const files = { 'scripts/input.js': fs.readFileSync(path.join(dir, 'input.js'), 'utf8') };
+      const { a, b } = await differentialCheck(files, configRaw, scenario, name);
+      assert.ok(Array.isArray(a.effects));
+      assert.ok(Array.isArray(b.effects));
+    });
+  }
+}

package/test/try-catch-strip/config.json

@@ -0,0 +1 @@
+{"level": "risky"}

package/test/try-catch-strip/expected.js

@@ -0,0 +1,57 @@
+// R3: try/catch stripping in hot functions (risky).
+import { world, system } from '@minecraft/server';
+const __opR1Cache = new WeakMap();
+function __opR1Component(obj, key) {
+  let m = __opR1Cache.get(obj);
+  if (m === undefined) {
+    m = new Map();
+    __opR1Cache.set(obj, m);
+  }
+  let v = m.get(key);
+  if (v === undefined) {
+    v = obj.getComponent(key);
+    m.set(key, v);
+  }
+  return v;
+}
+function __opR1Field(obj, key) {
+  let m = __opR1Cache.get(obj);
+  if (m === undefined) {
+    m = new Map();
+    __opR1Cache.set(obj, m);
+  }
+  let v = m.get(key);
+  if (v === undefined) {
+    v = obj[key];
+    m.set(key, v);
+  }
+  return v;
+}
+function onTick(player) {
+  let x = 0;
+  x = player.location.y;
+  world.setDynamicProperty('x', x);
+}
+
+// Catch with a body: bails.
+function withCatchBody(player) {
+  let x = 0;
+  try {
+    x = player.location.y;
+  } catch (e) {
+    world.sendMessage('err');
+  }
+  world.setDynamicProperty('x2', x);
+}
+
+// Try body with a call: bails.
+function withCall(player) {
+  let x = 0;
+  try {
+    x = __opR1Component(player, "minecraft:health").currentValue;
+  } catch {}
+  world.setDynamicProperty('x3', x);
+}
+system.runInterval(() => onTick(world.getAllPlayers()[0]), 20);
+system.runInterval(() => withCatchBody(world.getAllPlayers()[0]), 20);
+system.runInterval(() => withCall(world.getAllPlayers()[0]), 20);

package/test/try-catch-strip/expects.json

@@ -0,0 +1 @@
+{"transforms": {"try-catch-strip": 1}, "warnings": 2, "bails": [{"transform": "R3", "reasonContains": "catch body"}]}