optipack 0.0.0-stage → 1.0.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('../src/harness/driver.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"}]}

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

@@ -0,0 +1,34 @@
+// R3: try/catch stripping in hot functions (risky).
+import { world, system } from '@minecraft/server';
+
+function onTick(player) {
+  let x = 0;
+  try {
+    x = player.location.y;
+  } catch {}
+  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 = player.getComponent('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/scenario.json

@@ -0,0 +1,28 @@
+{
+    "reads":  {
+                  "location:p1":  [
+                                      {
+                                          "y":  64,
+                                          "z":  2,
+                                          "x":  1
+                                      }
+                                  ]
+              },
+    "entry":  "scripts/input.js",
+    "steps":  [
+                  {
+                      "n":  5,
+                      "op":  "tick"
+                  }
+              ],
+    "state":  {
+                  "players":  [
+                                  {
+                                      "id":  "p1"
+                                  },
+                                  {
+                                      "id":  "p2"
+                                  }
+                              ]
+              }
+}

package/test/update-example-snapshot.mjs

@@ -0,0 +1,19 @@
+/**
+ * Snapshot updater: regenerates test/example-report-snapshot.json from the
+ * current pipeline over example/. Run: npm run update-snapshot
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const root = path.join(here, '..');
+
+const { runPack } = await import('../src/pipeline.js');
+const { normalizeConfig } = await import('../src/config.js');
+
+const out = fs.mkdtempSync(path.join(os.tmpdir(), 'optipack-snap-'));
+const report = runPack(path.join(root, 'example'), out, normalizeConfig({ level: 'balanced' }));
+fs.writeFileSync(path.join(here, 'example-report-snapshot.json'), report.serialize());
+console.log('snapshot updated: test/example-report-snapshot.json');

package/test/update-mock-stubs.mjs

@@ -0,0 +1,91 @@
+/**
+ * Generator for permissive @minecraft/* stubs.
+ * Reads runtime export names from the real index.d.ts of each module and
+ * writes test/mock/@minecraft/<module>.mjs stub files. Re-run after bumping
+ * the module versions in the versions map below.
+ *
+ * Usage: node test/update-mock-stubs.mjs   (requires $env:TEMP\mc-stubs with
+ * extracted packages, or it will pack them itself)
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const mockDir = path.join(here, '..', 'src', 'harness', 'mock', '@minecraft');
+
+// module -> version (latest stable/beta at time of writing)
+const MODULES = {
+  '@minecraft/server': '2.10.0',
+  '@minecraft/common': '1.3.0',
+  '@minecraft/debug-utilities': '1.0.0-beta.1.20.70-preview.20',
+  '@minecraft/diagnostics': '1.0.0-beta.1.21.70-preview.22',
+  '@minecraft/server-admin': '1.0.0-beta.11940b24',
+  '@minecraft/server-editor': '0.1.0-beta.1.20.20-preview.20',
+  '@minecraft/server-gametest': '1.0.0-beta.1.21.60-preview.24',
+  '@minecraft/server-graphics': '1.0.0',
+  '@minecraft/server-net': '1.0.0-beta.11940b24',
+};
+
+// Names implemented functionally in mock/@minecraft/server.mjs — excluded from
+// the generated extras (local exports shadow star re-exports anyway, but we
+// keep the extras file clean).
+const SERVER_FUNCTIONAL = new Set(['world', 'system', 'Entity', 'Dimension', 'Block', 'TicksPerSecond', 'GameMode']);
+
+function writeServerExtras(names, dtsPath) {
+  const extras = [...names].filter((n) => !SERVER_FUNCTIONAL.has(n)).sort();
+  const header =
+    `/**\n * Generated permissive exports for @minecraft/server (see test/update-mock-stubs.mjs).\n` +
+    ` * The functional surface (world, system, Entity, Dimension, Block, ...) lives in\n` +
+    ` * server.mjs; every OTHER runtime export of the real module is bound here to a\n` +
+    ` * permissive value so real-world scripts' named imports link under the harness.\n` +
+    ` * NOT a behavioral model of the engine module.\n */\n` +
+    `import { permissive } from '../permissive.mjs';\n\n`;
+  const body = extras.map((n) => `export const ${n} = permissive('server.${n}');`).join('\n');
+  fs.writeFileSync(path.join(mockDir, 'server-extras.mjs'), header + body + '\n');
+}
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mc-stub-gen-'));
+for (const [name, version] of Object.entries(MODULES)) {
+  const spec = `${name}@${version}`;
+  const tarball = execSync(`npm pack ${spec} --silent --pack-destination "${tmp}"`, { encoding: 'utf8' }).trim();
+  const dirName = tarball.replace(/\.tgz$/, '');
+  fs.mkdirSync(path.join(tmp, dirName), { recursive: true });
+  execSync(`tar -xzf "${path.join(tmp, tarball)}" -C "${path.join(tmp, dirName)}"`);
+  const dtsPath = path.join(tmp, dirName, 'package', 'index.d.ts');
+  const dts = fs.readFileSync(dtsPath, 'utf8');
+
+  // Runtime (value) exports: classes, functions, enums, consts, vars — plus
+  // explicit `export { ... }` lists. Type-only exports are skipped.
+  const names = new Set();
+  const re = /^export (?:declare )?(?:abstract )?(class|function|enum|const|var)\s+([A-Za-z0-9_$]+)/gm;
+  for (const m of dts.matchAll(re)) names.add(m[2]);
+  for (const m of dts.matchAll(/^export\s*\{([^}]+)\}/gm)) {
+    for (const part of m[1].split(',')) {
+      const n = part.trim().split(/\s+as\s+/)[0].trim();
+      if (/^[A-Za-z0-9_$]+$/.test(n)) names.add(n);
+    }
+  }
+  if (name === '@minecraft/server') {
+    // server.mjs implements these functionally; everything else is permissive.
+    writeServerExtras(names, dtsPath);
+    console.log(`@minecraft/server: ${names.size} runtime exports -> mock/@minecraft/server-extras.mjs (functional names excluded)`);
+    continue;
+  }
+
+  const short = name.replace('@minecraft/', '').replace(/\//g, '-');
+  const header =
+    `/**\n * Permissive stub of ${name}@${version} for the differential harness.\n` +
+    ` * Generated from the module's real index.d.ts (see test/update-mock-stubs.mjs).\n` +
+    ` * Every runtime export is a permissive value: callable, constructable, and\n` +
+    ` * chainable; calls and constructions record harness effects so differential\n` +
+    ` * equivalence holds. NOT a behavioral model of the engine module.\n */\n` +
+    `import { permissive } from '../permissive.mjs';\n\n`;
+  const body = [...names].sort().map((n) => `export const ${n} = permissive('${short}.${n}');`).join('\n');
+  fs.writeFileSync(path.join(mockDir, short + '.mjs'), header + body + '\n');
+  console.log(`${name}: ${names.size} runtime exports -> mock/@minecraft/${short}.mjs`);
+}
+fs.rmSync(tmp, { recursive: true, force: true });
+