optipack 1.0.0 → 1.0.1

package/test/fetch-corpus.mjs

@@ -0,0 +1,92 @@
+/**
+ * Fetch the real-world benchmark corpus.
+ *
+ * Downloads MIT-licensed community behavior-pack scripts from JaylyDev/ScriptAPI
+ * (used with attribution; see the header comment of each fetched file for its
+ * original author), assembles a runnable pack under test/corpus/jayly-pack/,
+ * and records the source commit in SOURCES.json.
+ *
+ * The corpus is gitignored — run `npm run fetch-corpus` before benching it.
+ */
+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 corpusDir = path.join(here, 'corpus');
+const repo = 'JaylyDev/ScriptAPI';
+
+// Self-registering modules (subscribe or runInterval at import time) that the
+// corpus pack's entry imports. Others ship in scripts/ for relative imports.
+const ENTRY_IMPORTS = [
+  './anti-nuker/index.js',
+  './anti-32k/index.js',
+  './anti-32k-event/index.js',
+  './world-border/index.js',
+  './health-display/index.js',
+  './player-death-event/index.js',
+];
+
+const manifest = {
+  format_version: 2,
+  header: {
+    name: 'optipack bench corpus (JaylyDev/ScriptAPI)',
+    description: 'Real-world community scripts assembled for optipack A/B benchmarking. Scripts are MIT-licensed by their original authors.',
+    uuid: '3f7c2d91-8a44-4e0b-9c55-1b2c3d4e5f60',
+    version: [1, 0, 0],
+    min_engine_version: [1, 21, 0],
+  },
+  modules: [
+    { type: 'data', uuid: '4a8d3e02-9b55-4f1c-8d66-2c3d4e5f6a70', version: [1, 0, 0] },
+    { type: 'script', language: 'javascript', uuid: '5b9e4f13-ac66-402d-9e77-3d4e5f6a7b80', entry: 'scripts/main.js', version: [1, 0, 0] },
+  ],
+  dependencies: [{ module_name: '@minecraft/server', version: '2.0.0' }],
+};
+
+// 1. Download + extract.
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'optipack-corpus-'));
+const tgz = path.join(tmp, 'repo.tar.gz');
+console.log(`fetching ${repo} tarball...`);
+execSync(`curl -sL "https://github.com/${repo}/archive/refs/heads/main.tar.gz" -o "${tgz}"`, { stdio: 'inherit' });
+fs.mkdirSync(path.join(tmp, 'x'), { recursive: true });
+execSync(`tar -xzf "${tgz}" -C "${path.join(tmp, 'x')}"`);
+const extracted = fs.readdirSync(path.join(tmp, 'x'))[0];
+const commit = execSync(`git ls-remote https://github.com/${repo}.git HEAD`, { encoding: 'utf8' }).trim().split(/\s+/)[0];
+
+// 2. Assemble the corpus pack.
+const packDir = path.join(corpusDir, 'jayly-pack');
+fs.rmSync(corpusDir, { recursive: true, force: true });
+fs.mkdirSync(path.join(packDir, 'scripts'), { recursive: true });
+fs.cpSync(path.join(tmp, 'x', extracted, 'scripts'), path.join(packDir, 'scripts'), { recursive: true });
+fs.writeFileSync(path.join(packDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+
+const imports = ENTRY_IMPORTS.map((rel) => `import '${rel}';`).join('\n');
+const entry = [
+  '// optipack bench corpus entry — imports real-world community scripts',
+  '// (JaylyDev/ScriptAPI, MIT). Each module self-registers its handlers.',
+  imports,
+  '',
+].join('\n');
+fs.writeFileSync(path.join(packDir, 'scripts', 'main.js'), entry);
+
+// 3. Record provenance.
+fs.writeFileSync(
+  path.join(corpusDir, 'SOURCES.json'),
+  JSON.stringify({
+    sources: [{ repo, commit, license: 'MIT', fetched: new Date().toISOString() }],
+    note: 'Scripts belong to their original authors (see file headers). Fetched for optipack benchmarking only.',
+  }, null, 2) + '\n'
+);
+fs.rmSync(tmp, { recursive: true, force: true });
+
+const scriptCount = (function walk(dir) {
+  return fs.readdirSync(dir, { withFileTypes: true }).reduce((n, e) => {
+    const p = path.join(dir, e.name);
+    return n + (e.isDirectory() ? walk(p) : e.name.endsWith('.js') ? 1 : 0);
+  }, 0);
+})(path.join(packDir, 'scripts'));
+
+console.log(`corpus ready: ${packDir} (${scriptCount} script files, ${repo}@${commit.slice(0, 9)})`);
+console.log('next: node bin/optipack.js bench test/corpus/jayly-pack --scenario test/corpus/jayly-scenario.json');

package/test/infra.test.mjs

@@ -241,6 +241,16 @@ test('CLI: --level safe skips balanced passes', () => {
   assert.ok(safeCode.includes('player.location.x'), 'B1 did not run at safe level');
 });
 
+test('CLI: bench reports boundary crossings and identical effects', () => {
+  // Use the example pack with the server-ui-forms scenario (players p1 ready).
+  const scenarioPath = path.join(root, 'test', 'server-ui-forms', 'scenario.json');
+  const res = spawnSync(process.execPath, [CLI, 'bench', path.join(root, 'example'), '--ticks', '40', '--scenario', scenarioPath], { encoding: 'utf8' });
+  assert.equal(res.status, 0, res.stderr);
+  assert.match(res.stdout, /boundary\.location/, 'crossing table present');
+  assert.match(res.stdout, /transforms applied: \d+/, 'transform count present');
+  assert.match(res.stdout, /original/, 'A/B columns present');
+});
+
 test('CLI: risky passes only run at risky level or explicit config', () => {
   const src = [
     "import { world, system } from '@minecraft/server';",

package/test/server-ui-forms/expected.js

@@ -0,0 +1,15 @@
+// Differential coverage for @minecraft/server-ui through the harness mock.
+import { world, system } from '@minecraft/server';
+import { ActionFormData, MessageFormData, uiManager } from '@minecraft/server-ui';
+const _opLift = () => onTick(world.getAllPlayers()[0]);
+function onTick(player) {
+  const menu = new ActionFormData().title('Main Menu').body('Choose an option').button('Play').button('Settings');
+  menu.show(player);
+  if (player.location.y > 64) {
+    const notice = new MessageFormData().title('Notice').body('You are high up').button1('OK').button2('Dismiss');
+    uiManager.showPlayer(player, notice);
+  }
+}
+world.afterEvents.worldLoad.subscribe(() => {
+  system.runInterval(_opLift, 1);
+});

package/test/server-ui-forms/expects.json

@@ -0,0 +1 @@
+{"hotFunctions": 3, "transforms": {"closure-lift": 1}}

package/test/server-ui-forms/input.js

@@ -0,0 +1,25 @@
+// Differential coverage for @minecraft/server-ui through the harness mock.
+import { world, system } from '@minecraft/server';
+import { ActionFormData, MessageFormData, uiManager } from '@minecraft/server-ui';
+
+function onTick(player) {
+  const menu = new ActionFormData()
+    .title('Main Menu')
+    .body('Choose an option')
+    .button('Play')
+    .button('Settings');
+  menu.show(player);
+
+  if (player.location.y > 64) {
+    const notice = new MessageFormData()
+      .title('Notice')
+      .body('You are high up')
+      .button1('OK')
+      .button2('Dismiss');
+    uiManager.showPlayer(player, notice);
+  }
+}
+
+world.afterEvents.worldLoad.subscribe(() => {
+  system.runInterval(() => onTick(world.getAllPlayers()[0]), 1);
+});

package/test/server-ui-forms/scenario.json

@@ -0,0 +1 @@
+{"entry": "scripts/input.js", "reads": {"location:p1": [{"x": 1, "y": 70, "z": 2}, {"x": 2, "y": 60, "z": 3}]}, "state": {"players": [{"id": "p1"}]}, "steps": [{"op": "fire", "event": "world.afterEvents.worldLoad", "payload": {}}, {"op": "tick", "n": 10}]}

package/test/transforms.test.mjs

@@ -1,8 +1,8 @@
-/**
+/**
  * 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
+ * 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';
@@ -14,7 +14,7 @@ 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 { differentialCheck } = await import('../src/harness/driver.js');
 
 const dirs = fixtureDirs(here);
 

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 });
+

package/test/loader-hooks.mjs

@@ -1,38 +0,0 @@
-/**
- * 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);
-}