optipack 0.0.0-stage → 1.0.0

package/test/dead-code/expected.js

@@ -0,0 +1,14 @@
+// S2: dead code shapes.
+export function f(x) {
+  return x;
+}
+export function g() {
+  return 1;
+}
+export function w() {
+  return 'after';
+}
+const kept = 3;
+export function h() {
+  return kept;
+}

package/test/dead-code/expects.json

@@ -0,0 +1,5 @@
+{
+    "transforms":  {
+                       "dead-code":  4
+                   }
+}

package/test/dead-code/input.js

@@ -0,0 +1,23 @@
+// S2: dead code shapes.
+export function f(x) {
+  return x;
+  console.log('dead');
+}
+export function g() {
+  if (true) {
+    return 1;
+  } else {
+    return 2;
+  }
+}
+export function w() {
+  while (false) {
+    sideEffect();
+  }
+  return 'after';
+}
+const unused = 1 + 2;
+const kept = 3;
+export function h() {
+  return kept;
+}

package/test/destructure-to-direct/expected.js

@@ -0,0 +1,37 @@
+// S6: destructure-to-direct inside a hot handler.
+import { world, system } from '@minecraft/server';
+function onTick(cfg) {
+  world.sendMessage('' + cfg.x + cfg.y);
+}
+
+// > 3 total uses: bails, stays untouched.
+function tooManyUses(cfg) {
+  const {
+    x,
+    y
+  } = cfg;
+  world.sendMessage('' + x);
+  world.sendMessage('' + y);
+  world.sendMessage('' + x);
+  world.sendMessage('' + y);
+}
+
+// Default value hoisted to an if.
+function withDefault(cfg) {
+  let z = cfg.z;
+  if (z === undefined) z = 42;
+  world.sendMessage('' + cfg.x + z);
+}
+system.runInterval(() => {
+  onTick({
+    x: 1,
+    y: 2
+  });
+  tooManyUses({
+    x: 1,
+    y: 2
+  });
+  withDefault({
+    x: 1
+  });
+}, 20);

package/test/destructure-to-direct/expects.json

@@ -0,0 +1,11 @@
+{
+    "transforms":  {
+                       "destructure-to-direct":  2
+                   },
+    "bails":  [
+                  {
+                      "transform":  "S6",
+                      "reasonContains":  "total uses"
+                  }
+              ]
+}

package/test/destructure-to-direct/input.js

@@ -0,0 +1,28 @@
+// S6: destructure-to-direct inside a hot handler.
+import { world, system } from '@minecraft/server';
+
+function onTick(cfg) {
+  const { x, y } = cfg;
+  world.sendMessage('' + x + y);
+}
+
+// > 3 total uses: bails, stays untouched.
+function tooManyUses(cfg) {
+  const { x, y } = cfg;
+  world.sendMessage('' + x);
+  world.sendMessage('' + y);
+  world.sendMessage('' + x);
+  world.sendMessage('' + y);
+}
+
+// Default value hoisted to an if.
+function withDefault(cfg) {
+  const { x, z = 42 } = cfg;
+  world.sendMessage('' + x + z);
+}
+
+system.runInterval(() => {
+  onTick({ x: 1, y: 2 });
+  tooManyUses({ x: 1, y: 2 });
+  withDefault({ x: 1 });
+}, 20);

package/test/destructure-to-direct/scenario.json

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

package/test/destructure-to-direct-bail/expected.js

@@ -0,0 +1,36 @@
+// S6 bails: nested patterns, rest, member-chain objects, loops.
+import { world, system } from '@minecraft/server';
+export function nested(cfg) {
+  const {
+    a: {
+      b
+    }
+  } = cfg;
+  return b;
+}
+export function withRest(cfg) {
+  const {
+    a,
+    ...rest
+  } = cfg;
+  return a + rest.length;
+}
+export function memberObj(player) {
+  const {
+    x,
+    y
+  } = player.location;
+  return x + y;
+}
+export function loopHead(list) {
+  for (const {
+    id
+  } of list) {
+    world.sendMessage(id);
+  }
+}
+system.runInterval(() => nested({
+  a: {
+    b: 1
+  }
+}), 20);

package/test/destructure-to-direct-bail/expects.json

@@ -0,0 +1,11 @@
+{
+    "transforms":  {
+                       "destructure-to-direct":  0
+                   },
+    "bails":  [
+                  {
+                      "transform":  "S6",
+                      "reasonContains":  "nested pattern"
+                  }
+              ]
+}

package/test/destructure-to-direct-bail/input.js

@@ -0,0 +1,25 @@
+// S6 bails: nested patterns, rest, member-chain objects, loops.
+import { world, system } from '@minecraft/server';
+
+export function nested(cfg) {
+  const { a: { b } } = cfg;
+  return b;
+}
+
+export function withRest(cfg) {
+  const { a, ...rest } = cfg;
+  return a + rest.length;
+}
+
+export function memberObj(player) {
+  const { x, y } = player.location;
+  return x + y;
+}
+
+export function loopHead(list) {
+  for (const { id } of list) {
+    world.sendMessage(id);
+  }
+}
+
+system.runInterval(() => nested({ a: { b: 1 } }), 20);

package/test/differential.test.mjs

@@ -0,0 +1,267 @@
+/**
+ * Bespoke differential scenarios.
+ *
+ * Every scenario loads the original and optimized entry with the mock
+ * @minecraft/server, runs identical steps (ticks / events), and requires the
+ * recorded EFFECTS to match exactly, in order. Reads return scripted sequences
+ * so data flows deterministically; eliminated reads are invisible by design.
+ */
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { differentialCheck, runVariant, pathToUrl, buildVariantPack } from './harness/setup.js';
+
+const PLAYER_READS = {
+  'location:p1': [{ x: 1, y: 64, z: 2 }, { x: 2, y: 65, z: 3 }],
+  'location:p2': [{ x: 5, y: 70, z: 6 }, { x: 6, y: 71, z: 7 }],
+  'name:p1': ['Alice'],
+  'name:p2': ['Bob'],
+};
+
+const TWO_PLAYERS = { players: [{ id: 'p1' }, { id: 'p2' }] };
+
+test('differential: hot tick loop with heavy host reads (S4/S5/S7/B1/B3/B4)', async () => {
+  const main = [
+    "import { world, system } from '@minecraft/server';",
+    '',
+    'function onTick() {',
+    '  const players = world.getAllPlayers();',
+    '  let report = "";',
+    '  for (let i = 0; i < players.length; i++) {',
+    '    const p = players[i];',
+    '    report += p.name + "@" + p.location.x + "," + p.location.x;',
+    '    p.setDynamicProperty("optipack:x", p.location.x);',
+    '    let baseline = 0;',
+    '    for (let j = 0; j < 3; j++) {',
+    '      baseline += p.location.y;',
+    '    }',
+    '    p.setDynamicProperty("optipack:baseline", baseline);',
+    '  }',
+    '  if (report.length > 0) {',
+    '    world.sendMessage(report);',
+    '  }',
+    '  const zones = ["overworld", "nether", "the_end"].filter((z) => z.length > 4);',
+    '  for (const z of zones) {',
+    '    world.setDynamicProperty("optipack:zone:" + z, true);',
+    '  }',
+    '  const doubled = ["a", "bb"].map((v) => v + v);',
+    '  world.setDynamicProperty("optipack:doubled", doubled.join(","));',
+    '}',
+    '',
+    'system.runInterval(onTick, 20);',
+  ].join('\n');
+
+  const scenario = {
+    entry: 'scripts/main.js',
+    reads: PLAYER_READS,
+    state: TWO_PLAYERS,
+    steps: [{ op: 'tick', n: 40 }],
+  };
+  await differentialCheck({ 'scripts/main.js': main }, { level: 'balanced' }, scenario, 'hot-tick-loop');
+});
+
+test('differential: event-driven worldLoad -> runInterval -> playerSpawn', async () => {
+  const main = [
+    "import { world, system } from '@minecraft/server';",
+    "import { makeGreeting } from './util.js';",
+    '',
+    'world.afterEvents.worldLoad.subscribe(() => {',
+    "  world.sendMessage('loaded');",
+    '  system.runInterval(onTick, 10);',
+    '  world.afterEvents.playerSpawn.subscribe(onSpawn);',
+    '});',
+    '',
+    'function onTick() {',
+    '  const players = world.getAllPlayers();',
+    '  for (const p of players) {',
+    "    p.setDynamicProperty('seen', true);",
+    '  }',
+    '}',
+    '',
+    'function onSpawn(ev) {',
+    '  const p = ev.player;',
+    '  if (!p) return;',
+    '  world.sendMessage(makeGreeting(p.name));',
+    "  p.setDynamicProperty('spawned', 1);",
+    '}',
+  ].join('\n');
+
+  const util = [
+    "const PREFIX = 'hello ';",
+    'export function makeGreeting(name) {',
+    '  return PREFIX + name;',
+    '}',
+  ].join('\n');
+
+  const scenario = {
+    entry: 'scripts/main.js',
+    reads: PLAYER_READS,
+    state: TWO_PLAYERS,
+    steps: [
+      { op: 'fire', event: 'world.afterEvents.worldLoad', payload: {} },
+      { op: 'tick', n: 25 },
+      { op: 'fire', event: 'world.afterEvents.playerSpawn', payload: { player: { __entity: 'p1' } } },
+      { op: 'tick', n: 5 },
+    ],
+  };
+  await differentialCheck({ 'scripts/main.js': main, 'scripts/util.js': util }, { level: 'balanced' }, scenario, 'event-driven');
+});
+
+test('differential: runJob generator with yield barriers', async () => {
+  const main = [
+    "import { world, system } from '@minecraft/server';",
+    '',
+    'function* chunkScan() {',
+    '  for (let cx = 0; cx < 3; cx++) {',
+    "    const before = world.getDynamicProperty('scan:' + cx);",
+    '    yield;',
+    "    world.setDynamicProperty('scan:' + cx, (before ?? 0) + 1);",
+    '  }',
+    '  yield;',
+    "  world.sendMessage('scan done');",
+    '}',
+    '',
+    'world.afterEvents.worldLoad.subscribe(() => {',
+    '  system.runJob(chunkScan());',
+    '});',
+  ].join('\n');
+
+  const scenario = {
+    entry: 'scripts/main.js',
+    reads: { 'world.dp:scan:0': [0], 'world.dp:scan:1': [10], 'world.dp:scan:2': [20] },
+    state: {},
+    steps: [
+      { op: 'fire', event: 'world.afterEvents.worldLoad', payload: {} },
+      { op: 'tick', n: 10 },
+    ],
+  };
+  await differentialCheck({ 'scripts/main.js': main }, { level: 'balanced' }, scenario, 'run-job');
+});
+
+test('differential: risky cross-tick cache stays effects-equivalent', async () => {
+  const main = [
+    "import { world, system } from '@minecraft/server';",
+    '',
+    'function onTick(player) {',
+    '  const health = player.getComponent("minecraft:health");',
+    '  if (health) {',
+    '    player.setDynamicProperty("hp", health.currentValue);',
+    '  }',
+    '  player.setDynamicProperty("id", player.id);',
+    '}',
+    '',
+    'system.runInterval(() => onTick(world.getAllPlayers()[0]), 1);',
+  ].join('\n');
+
+  const scenario = {
+    entry: 'scripts/main.js',
+    reads: {
+      // Stable component value: R1's documented precondition (stale reads are
+      // only observable when the underlying component changes).
+      'component:p1:minecraft:health': [{ currentValue: 20 }],
+      'name:p1': ['Alice'],
+    },
+    state: { players: [{ id: 'p1' }] },
+    steps: [{ op: 'tick', n: 6 }],
+  };
+  await differentialCheck({ 'scripts/main.js': main }, { level: 'risky' }, scenario, 'cross-tick-cache');
+});
+
+test('differential: string building over many ticks (B3 O(n^2) fix)', async () => {
+  const main = [
+    "import { world, system } from '@minecraft/server';",
+    '',
+    'function onTick() {',
+    '  const players = world.getAllPlayers();',
+    '  let scoreboard = "";',
+    '  for (let i = 0; i < players.length; i++) {',
+    '    scoreboard += players[i].name + ";";',
+    '  }',
+    '  world.setDynamicProperty("scoreboard", scoreboard);',
+    '}',
+    '',
+    'system.runInterval(onTick, 1);',
+  ].join('\n');
+
+  const scenario = {
+    entry: 'scripts/main.js',
+    reads: PLAYER_READS,
+    state: TWO_PLAYERS,
+    steps: [{ op: 'tick', n: 12 }],
+  };
+  const { a, b } = await differentialCheck({ 'scripts/main.js': main }, { level: 'balanced' }, scenario, 'string-build');
+  // The optimized effect list must contain exactly the same number of
+  // setDynamicProperty effects with the same joined values.
+  assert.equal(a.effects.length, b.effects.length);
+});
+
+test('differential: guards and optional chains (B5) across ticks', async () => {
+  const main = [
+    "import { world, system } from '@minecraft/server';",
+    '',
+    'function onTick(ev) {',
+    '  const p = ev.player;',
+    '  if (!p) return;',
+    "  world.sendMessage('n=' + p?.name);",
+    "  p.setDynamicProperty('x', p?.location.x);",
+    '}',
+    '',
+    'world.afterEvents.playerJoin.subscribe((ev) => onTick(ev));',
+    'system.runInterval(() => onTick({ player: null }), 20);',
+  ].join('\n');
+
+  const scenario = {
+    entry: 'scripts/main.js',
+    reads: PLAYER_READS,
+    state: TWO_PLAYERS,
+    steps: [
+      { op: 'fire', event: 'world.afterEvents.playerJoin', payload: { player: { __entity: 'p1' } } },
+      { op: 'tick', n: 3 },
+    ],
+  };
+  await differentialCheck({ 'scripts/main.js': main }, { level: 'balanced' }, scenario, 'null-guard');
+});
+
+test('differential: destructure-to-direct with mutation via property access', async () => {
+  const main = [
+    "import { world, system } from '@minecraft/server';",
+    '',
+    'function onTick(cfg) {',
+    '  const { label, weight } = cfg;',
+    "  world.sendMessage(label + ':' + weight);",
+    '}',
+    '',
+    'system.runInterval(() => onTick({ label: "cfg", weight: 3 }), 20);',
+  ].join('\n');
+
+  const scenario = {
+    entry: 'scripts/main.js',
+    reads: {},
+    state: TWO_PLAYERS,
+    steps: [{ op: 'tick', n: 5 }],
+  };
+  await differentialCheck({ 'scripts/main.js': main }, { level: 'balanced' }, scenario, 'destructure');
+});
+
+test('differential: closure lift with registrations', async () => {
+  const main = [
+    "import { world, system } from '@minecraft/server';",
+    '',
+    "const GREETING = 'hi';",
+    '',
+    'world.afterEvents.worldLoad.subscribe(() => {',
+    "  const announce = () => world.sendMessage(GREETING + ':lifted');",
+    '  system.runInterval(announce, 30);',
+    '});',
+  ].join('\n');
+
+  const scenario = {
+    entry: 'scripts/main.js',
+    reads: {},
+    state: {},
+    steps: [
+      { op: 'fire', event: 'world.afterEvents.worldLoad', payload: {} },
+      { op: 'tick', n: 65 },
+    ],
+  };
+  await differentialCheck({ 'scripts/main.js': main }, { level: 'balanced' }, scenario, 'closure-lift');
+});

package/test/dynprop-hoist/expected.js

@@ -0,0 +1,24 @@
+// B4: dynamic property reads hoisted out of hot loops.
+import { world, system } from '@minecraft/server';
+function onTick(player) {
+  let score = 0;
+  const _opDP = player.getDynamicProperty("optipack:active");
+  for (let i = 0; i < 4; i++) {
+    if (_opDP === true) {
+      score += 1;
+    }
+  }
+  world.setDynamicProperty('score', score);
+}
+
+// Loop contains another call: bails.
+function withOtherCall(player) {
+  let score = 0;
+  for (let i = 0; i < 4; i++) {
+    score += player.getDynamicProperty('optipack:n');
+    world.sendMessage('x');
+  }
+  world.setDynamicProperty('score2', score);
+}
+system.runInterval(() => onTick(world.getAllPlayers()[0]), 20);
+system.runInterval(() => withOtherCall(world.getAllPlayers()[0]), 20);

package/test/dynprop-hoist/expects.json

@@ -0,0 +1,11 @@
+{
+    "transforms":  {
+                       "dynprop-hoist":  1
+                   },
+    "bails":  [
+                  {
+                      "transform":  "B4",
+                      "reasonContains":  "calls other than"
+                  }
+              ]
+}

package/test/dynprop-hoist/input.js

@@ -0,0 +1,25 @@
+// B4: dynamic property reads hoisted out of hot loops.
+import { world, system } from '@minecraft/server';
+
+function onTick(player) {
+  let score = 0;
+  for (let i = 0; i < 4; i++) {
+    if (player.getDynamicProperty('optipack:active') === true) {
+      score += 1;
+    }
+  }
+  world.setDynamicProperty('score', score);
+}
+
+// Loop contains another call: bails.
+function withOtherCall(player) {
+  let score = 0;
+  for (let i = 0; i < 4; i++) {
+    score += player.getDynamicProperty('optipack:n');
+    world.sendMessage('x');
+  }
+  world.setDynamicProperty('score2', score);
+}
+
+system.runInterval(() => onTick(world.getAllPlayers()[0]), 20);
+system.runInterval(() => withOtherCall(world.getAllPlayers()[0]), 20);

package/test/dynprop-hoist/scenario.json

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

package/test/example-report-snapshot.json

@@ -0,0 +1,107 @@
+{
+  "level": "balanced",
+  "files": [
+    {
+      "path": "scripts/drops.js",
+      "hotFunctions": 0,
+      "transforms": {},
+      "bails": [],
+      "lint": [],
+      "residualAllocs": {
+        "closures": 0,
+        "arrays": 0,
+        "objects": 0
+      },
+      "bytes": {
+        "before": 710,
+        "after": 709
+      },
+      "warnings": 0
+    },
+    {
+      "path": "scripts/main.js",
+      "hotFunctions": 4,
+      "transforms": {
+        "for-of-to-indexed": 1,
+        "array-methods-to-loops": 1,
+        "hoist-invariant-members": 1,
+        "cache-getter-chains": 1,
+        "string-build": 1
+      },
+      "bails": [
+        {
+          "line": 18,
+          "transform": "S4",
+          "reason": "iterable not provably an array"
+        },
+        {
+          "line": 18,
+          "transform": "S6",
+          "reason": "declaration is a loop head"
+        },
+        {
+          "line": 48,
+          "transform": "S7",
+          "reason": "loop body contains calls (mutation barrier)"
+        },
+        {
+          "line": 20,
+          "transform": "B1",
+          "reason": "chain .location.y repeats but uses are split by call/assignment barriers"
+        },
+        {
+          "line": 48,
+          "transform": "B4",
+          "reason": "loop contains await/yield"
+        }
+      ],
+      "lint": [
+        {
+          "line": 16,
+          "rule": "per-tick-getAllPlayers",
+          "message": "getAllPlayers() runs unconditionally inside a per-tick callback — prefer event-driven updates or caching between ticks"
+        },
+        {
+          "line": 49,
+          "rule": "dynprop-in-loop",
+          "message": "getDynamicProperty inside a tick loop — reads cross the host boundary every iteration"
+        }
+      ],
+      "residualAllocs": {
+        "closures": 0,
+        "arrays": 1,
+        "objects": 0
+      },
+      "bytes": {
+        "before": 2217,
+        "after": 2523
+      },
+      "warnings": 0
+    },
+    {
+      "path": "scripts/util.js",
+      "hotFunctions": 0,
+      "transforms": {
+        "bool-simplify": 1
+      },
+      "bails": [],
+      "lint": [],
+      "residualAllocs": {
+        "closures": 0,
+        "arrays": 0,
+        "objects": 0
+      },
+      "bytes": {
+        "before": 820,
+        "after": 807
+      },
+      "warnings": 0
+    }
+  ],
+  "warnings": [],
+  "totals": {
+    "transforms": 6,
+    "bails": 5,
+    "warnings": 0
+  }
+}