optipack 0.0.0-stage → 1.0.1

package/src/bench.js

@@ -0,0 +1,231 @@
+/**
+ * `optipack bench` — A/B benchmark of a pack's original vs optimized scripts
+ * under the harness mock.
+ *
+ * Measures, for identical simulated scenarios:
+ *  - host-boundary crossings by kind (the metric optipack exists to reduce:
+ *    location reads, getComponent, getDynamicProperty, getEntities, ...).
+ *    Engine-independent: a crossing is a crossing in V8 or QuickJS.
+ *  - wall-clock time (INDICATIVE ONLY: Node is V8 with a JIT, Minecraft is
+ *    QuickJS without one — use the in-game `/script profiler` workflow in
+ *    BENCHMARKING.md for authoritative numbers).
+ *  - effect-trace equality (a bench between non-equivalent builds is invalid
+ *    and is flagged).
+ *
+ * Determinism: a virtual clock replaces Date during variant execution and
+ * advances a fixed 50ms per tick, so time-gated script logic sees identical
+ * clocks on both sides regardless of how fast each variant actually runs.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { performance } from 'node:perf_hooks';
+
+import { makeRecorder, runVariant, assertSameEffects, pathToUrl, ensureHooks } from './harness/driver.js';
+import { runPack } from './pipeline.js';
+import { normalizeConfig } from './config.js';
+
+const TICK_MS = 50; // 20 TPS
+
+function installVirtualClock() {
+  const RealDate = Date;
+  let now = RealDate.now();
+  class VirtualDate extends RealDate {
+    constructor(...args) {
+      if (args.length === 0) super(now);
+      else super(...args);
+    }
+    static now() {
+      return now;
+    }
+  }
+  globalThis.Date = VirtualDate;
+  return {
+    advance(ms) { now += ms; },
+    restore() { globalThis.Date = RealDate; },
+  };
+}
+
+/**
+ * Run one variant end to end and collect measurements.
+ */
+async function measureVariant(entryAbsPath, variant, scenario, ticks) {
+  const clock = installVirtualClock();
+  const rec = makeRecorder({ reads: scenario.reads, state: scenario.state });
+  globalThis.__opkRecorder = rec;
+  const t = { importMs: 0, ticksMs: 0 };
+  try {
+    const importStart = performance.now();
+    await import(`${pathToUrl(entryAbsPath)}?opkv=${variant}&t=${Date.now()}-${Math.floor(performance.now() * 1000)}`);
+    t.importMs = performance.now() - importStart;
+
+    const steps = scenario.steps || [];
+    const tickStart = performance.now();
+    for (const step of steps) {
+      if (step.op === 'tick') {
+        for (let i = 0; i < step.n; i++) {
+          rec.tick(1);
+          clock.advance(TICK_MS);
+        }
+      } else if (step.op === 'fire') {
+        rec.fire(step.event, step.payload);
+      } else if (step.op === 'fireMany') {
+        for (let i = 0; i < (step.count || 1); i++) rec.fire(step.event, step.payload);
+      } else if (step.op === 'call') {
+        step.fn(rec);
+      }
+    }
+    if (ticks > 0) {
+      for (let i = 0; i < ticks; i++) {
+        rec.tick(1);
+        clock.advance(TICK_MS);
+      }
+    }
+    t.ticksMs = performance.now() - tickStart;
+  } finally {
+    globalThis.__opkRecorder = null;
+    clock.restore();
+  }
+  return {
+    counters: rec.counters,
+    effects: rec.effects,
+    wall: t,
+    totalTicks: rec.tickCounter,
+  };
+}
+
+function compareCounters(a, b) {
+  const keys = [...new Set([...Object.keys(a), ...Object.keys(b)])].sort();
+  return keys.map((k) => {
+    const av = a[k] || 0;
+    const bv = b[k] || 0;
+    const delta = bv - av;
+    const pct = av === 0 ? (bv === 0 ? 0 : 100) : Math.round((delta / av) * 100);
+    return { kind: k, original: av, optimized: bv, delta, pct };
+  });
+}
+
+/**
+ * Full bench: build the optimized pack, measure both variants, report.
+ */
+export async function benchPack(inputDirRaw, options = {}) {
+  const inputDir = path.resolve(inputDirRaw);
+  const {
+    ticks = 200,
+    entry = null,
+    scenario: scenarioPath = null,
+    quiet = false,
+  } = options;
+
+  const configRaw = { ...(options.config || {}) };
+  if (options.level) configRaw.level = options.level;
+  const config = normalizeConfig(configRaw);
+  ensureHooks();
+  const outputDir = fs.mkdtempSync(path.join(os.tmpdir(), 'optipack-bench-'));
+  const report = runPack(inputDir, outputDir, config);
+
+  // Locate the entry: explicit, manifest, or first script with subscribers.
+  let entryRel = entry;
+  if (!entryRel) {
+    const manifestPath = path.join(inputDir, 'manifest.json');
+    if (fs.existsSync(manifestPath)) {
+      try {
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8').replace(/^\uFEFF/, ''));
+        const scriptModule = (manifest.modules || []).find((m) => m.type === 'script');
+        if (scriptModule && scriptModule.entry) entryRel = scriptModule.entry;
+      } catch { /* fall through */ }
+    }
+  }
+  if (!entryRel) {
+    const scripts = report.files.map((f) => f.path);
+    entryRel = scripts[0];
+  }
+  if (!entryRel) throw new Error('bench: pack has no script files');
+  if (!report.files.some((f) => f.path === entryRel)) {
+    throw new Error(`bench: entry "${entryRel}" is not among the pack's script files`);
+  }
+
+  const scenario = scenarioPath
+    ? JSON.parse(fs.readFileSync(scenarioPath, 'utf8').replace(/^\uFEFF/, ''))
+    : { reads: {}, state: {}, steps: [] };
+
+  const entryOriginal = path.join(inputDir, entryRel);
+  const entryOptimized = path.join(outputDir, entryRel);
+
+  // 3 alternating rounds per variant; report the median tick-phase time. A
+  // single round is dominated by V8 JIT warm-up noise (Node is only indicative
+  // anyway — see BENCHMARKING.md for the in-game workflow).
+  const rounds = 3;
+  const run = (v) => measureVariant(v === 'orig' ? entryOriginal : entryOptimized, v, scenario, ticks);
+  const aRuns = [];
+  const bRuns = [];
+  for (let i = 0; i < rounds; i++) {
+    aRuns.push(await run('orig'));
+    bRuns.push(await run('opt'));
+  }
+  const a = aRuns[0];
+  const b = bRuns[0];
+  a.wall.ticksMs = median(aRuns.map((r) => r.wall.ticksMs));
+  b.wall.ticksMs = median(bRuns.map((r) => r.wall.ticksMs));
+
+  let identical = true;
+  try {
+    assertSameEffects(a, b, 'bench');
+  } catch (e) {
+    identical = false;
+    if (!quiet) console.error(`optipack bench: WARNING — effect traces diverge, benchmark is not meaningful:\n${e.message}`);
+  }
+
+  const counters = compareCounters(a.counters, b.counters);
+  const totalCrossings = (v) => Object.values(v).reduce((x, y) => x + y, 0);
+  const result = {
+    pack: inputDir,
+    entry: entryRel,
+    ticks: a.totalTicks,
+    level: config.level,
+    effectsIdentical: identical,
+    boundary: counters,
+    boundaryTotals: { original: totalCrossings(a.counters), optimized: totalCrossings(b.counters) },
+    wall: {
+      original: a.wall,
+      optimized: b.wall,
+      note: 'Node/V8 numbers are indicative only; Minecraft runs QuickJS (no JIT).',
+    },
+    transforms: report.totals.transforms,
+  };
+
+  if (!quiet) printBench(result);
+  return result;
+}
+
+function fmtPct(pct) {
+  const s = pct > 0 ? `+${pct}%` : `${pct}%`;
+  return s;
+}
+
+function median(values) {
+  const sorted = [...values].sort((x, y) => x - y);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+
+export function printBench(result) {
+  const rows = result.boundary;
+  const width = Math.max(10, ...rows.map((r) => r.kind.length));
+  console.log(`optipack bench — ${result.pack} (entry ${result.entry}, ${result.ticks} ticks, level ${result.level})`);
+  if (!result.effectsIdentical) {
+    console.log('  !! effect traces DIVERGE — the two builds are not behavior-equivalent; treat numbers with suspicion');
+  }
+  console.log(`  ${'boundary crossing'.padEnd(width)}  original  optimized  delta`);
+  for (const r of rows) {
+    console.log(`  ${r.kind.padEnd(width)}  ${String(r.original).padStart(8)}  ${String(r.optimized).padStart(9)}  ${fmtPct(r.pct)}`);
+  }
+  const tot = result.boundaryTotals;
+  const totalPct = tot.original === 0 ? 0 : Math.round(((tot.optimized - tot.original) / tot.original) * 100);
+  console.log(`  ${'TOTAL'.padEnd(width)}  ${String(tot.original).padStart(8)}  ${String(tot.optimized).padStart(9)}  ${fmtPct(totalPct)}`);
+  const w = result.wall;
+  const usPerTick = (v) => (result.ticks > 0 ? Math.round((v.ticksMs / result.ticks) * 1000) : 0);
+  console.log(`  transforms applied: ${result.transforms}`);
+  console.log(`  wall (indicative, Node/V8): original ${w.original.ticksMs.toFixed(1)}ms (${usPerTick(w.original)}µs/tick)` +
+    `, optimized ${w.optimized.ticksMs.toFixed(1)}ms (${usPerTick(w.optimized)}µs/tick)`);
+}

package/src/cli.js

@@ -0,0 +1,245 @@
+/**
+ * optipack CLI.
+ *
+ *   optipack <inputPackDir> <outputPackDir> [options]
+ *   optipack bench <inputPackDir> [options]
+ *
+ * Exit codes: 0 success · 1 usage/config error · 2 parse failure · 3 internal error
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { Command } from 'commander';
+
+import { loadConfigFile, mergeCliOverrides, LEVELS } from './config.js';
+import { runPack, ParseFailureError, InternalError } from './pipeline.js';
+import { PASS_IDS, PASS_CODES } from './passes/index.js';
+import { unifiedDiff } from './diff.js';
+
+function parseBoolOpt(v) {
+  if (v === 'true' || v === '' || v === undefined) return true;
+  if (v === 'false') return false;
+  // Signal an invalid value; validated by the caller.
+  return v;
+}
+
+function parseOptInt(v) {
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) && n >= 0 ? n : undefined;
+}
+
+async function runOptimize(inputDir, outputDir, opts) {
+  try {
+    const exit = await runOptimizeInner(inputDir, outputDir, opts);
+    process.exitCode = exit;
+    return exit;
+  } catch (e) {
+    process.exitCode = 3;
+    console.error(`optipack: internal error — ${e && e.stack ? e.stack : String(e)}`);
+    return 3;
+  }
+}
+
+async function runOptimizeInner(inputDir, outputDir, opts) {
+  if (!inputDir || !outputDir) {
+    console.error('optipack: both <inputPackDir> and <outputPackDir> are required');
+    return 1;
+  }
+  if (opts.level !== undefined && !LEVELS.includes(opts.level)) {
+    console.error(`optipack: invalid --level "${opts.level}" (expected one of ${LEVELS.join(', ')})`);
+    return 1;
+  }
+  if (opts.lint !== undefined && typeof opts.lint !== 'boolean') {
+    console.error('optipack: --lint expects true or false');
+    return 1;
+  }
+
+  // Resolve config file: explicit path, else ./optipack.config.json.
+  let configPath = opts.config;
+  if (configPath && !fs.existsSync(configPath)) {
+    console.error(`optipack: config file not found: ${configPath}`);
+    return 1;
+  }
+  let config;
+  try {
+    const loaded = loadConfigFile(configPath);
+    config = loaded.config;
+    configPath = loaded.path;
+  } catch (e) {
+    console.error(`optipack: ${e.message}`);
+    return 1;
+  }
+
+  const cli = {
+    level: opts.level,
+    only: opts.only,
+    except: opts.except,
+    lint: opts.lint,
+    config: configPath,
+  };
+  try {
+    config = mergeCliOverrides(config, cli, PASS_IDS, PASS_CODES);
+  } catch (e) {
+    console.error(`optipack: ${e.message}`);
+    return 1;
+  }
+
+  const dryRun = !!opts.dryRun;
+  const reportPath = opts.report !== undefined
+    ? opts.report
+    : path.join(outputDir, 'optipack-report.json');
+
+  // Capture original sources for --diff.
+  const beforeSources = new Map();
+  if (opts.diff) {
+    const { walkPack } = await import('./pack-walker.js');
+    if (fs.existsSync(inputDir)) {
+      const { scripts } = walkPack(inputDir);
+      for (const s of scripts) beforeSources.set(s.relPath, fs.readFileSync(s.abs, 'utf8'));
+    }
+  }
+
+  try {
+    const report = runPack(inputDir, outputDir, config, { dryRun });
+    const json = report.serialize();
+
+    if (dryRun) {
+      if (opts.report !== undefined) {
+        fs.mkdirSync(path.dirname(reportPath), { recursive: true });
+        fs.writeFileSync(reportPath, json);
+        console.log(`optipack: dry run — wrote report to ${reportPath} (no pack files written)`);
+      } else {
+        console.log(json);
+      }
+    } else {
+      fs.mkdirSync(path.dirname(reportPath), { recursive: true });
+      fs.writeFileSync(reportPath, json);
+    }
+
+    if (opts.diff) {
+      const { walkPack } = await import('./pack-walker.js');
+      const { scripts } = walkPack(inputDir);
+      for (const s of scripts) {
+        const outAbs = path.join(outputDir, s.relPath);
+        if (!fs.existsSync(outAbs)) continue;
+        const after = fs.readFileSync(outAbs, 'utf8');
+        const before = beforeSources.get(s.relPath) ?? '';
+        const d = unifiedDiff(s.relPath, s.relPath, before, after);
+        if (d) process.stdout.write(d);
+      }
+    }
+
+    if (!dryRun || opts.report !== undefined) {
+      const t = report.totals;
+      console.log(
+        `optipack: ${report.files.length} script file(s), level ${report.level}, ` +
+        `${t.transforms} transform(s) applied, ${t.bails} bail(s), ${t.warnings} warning(s)`
+      );
+      console.log(`optipack: report written to ${reportPath}${dryRun ? ' (dry run: no pack files written)' : ''}`);
+    }
+    return 0;
+  } catch (e) {
+    if (e instanceof ParseFailureError) {
+      console.error(`optipack: parse failure — ${e.message}`);
+      return 2;
+    }
+    if (e instanceof InternalError) {
+      console.error(`optipack: internal error — ${e.message}`);
+      return 3;
+    }
+    if (e && e.code === 1) {
+      console.error(`optipack: ${e.message}`);
+      return 1;
+    }
+    console.error(`optipack: internal error — ${e && e.stack ? e.stack : String(e)}`);
+    return 3;
+  }
+}
+
+async function runBench(packDir, opts) {
+  const run = async () => {
+    const { benchPack } = await import('./bench.js');
+    const result = await benchPack(packDir, {
+      ticks: opts.ticks,
+      entry: opts.entry,
+      scenario: opts.scenario,
+      config: opts.config && JSON.parse(fs.readFileSync(opts.config, 'utf8').replace(/^\uFEFF/, '')),
+      level: opts.level,
+    });
+    if (opts.json) {
+      fs.mkdirSync(path.dirname(opts.json), { recursive: true });
+      fs.writeFileSync(opts.json, JSON.stringify(result, null, 2) + '\n');
+      console.log(`optipack bench: JSON written to ${opts.json}`);
+    }
+    return result.effectsIdentical ? 0 : 1;
+  };
+  try {
+    const code = await run();
+    process.exitCode = code;
+    return code;
+  } catch (e) {
+    const code = e instanceof ParseFailureError ? 2
+      : e instanceof InternalError ? 3
+        : 1;
+    console.error(`optipack bench: ${e instanceof ParseFailureError || e instanceof InternalError ? e.message : (e && e.message ? e.message : String(e))}`);
+    process.exitCode = code;
+    return code;
+  }
+}
+
+export async function main(argv) {
+  const program = new Command();
+  program
+    .name('optipack')
+    .description('QuickJS-targeted micro-optimizing pre-processor for Minecraft Bedrock behavior-pack scripts')
+    .version('1.0.0')
+    .exitOverride()
+    .configureOutput({ writeErr: () => {} }); // actions print errors themselves
+
+  program
+    .command('bench')
+    .description('A/B benchmark: original vs optimized scripts under the harness mock (boundary crossings + indicative wall time). See BENCHMARKING.md for the in-game workflow.')
+    .argument('<inputPackDir>', 'behavior pack directory to benchmark')
+    .option('--ticks <n>', 'simulated ticks to run (default 200)', parseOptInt)
+    .option('--entry <path>', 'script entry to load (default: manifest script entry)')
+    .option('--scenario <path>', 'scenario JSON (reads/state/steps) driving events between ticks')
+    .option('--json <path>', 'also write the bench result as JSON to this path')
+    .option('--level <level>', 'optimization level for the optimized build')
+    .option('--config <path>', 'config file for the optimized build')
+    .action(function (packDir, cmdOpts, command) {
+      // --level is declared on both this subcommand and the default command;
+      // Commander absorbs shadowed names into the parent scope, so merge.
+      return runBench(packDir, command.optsWithGlobals());
+    });
+
+  program
+    .argument('<inputPackDir>', 'behavior pack directory to read')
+    .argument('<outputPackDir>', 'directory to write the optimized pack into')
+    .option('--level <level>', 'optimization level: safe | balanced | risky')
+    .option('--config <path>', 'config file (default: ./optipack.config.json when present)')
+    .option('--only <ids>', 'comma-separated transform ids to run exclusively')
+    .option('--except <ids>', 'comma-separated transform ids to skip')
+    .option('--dry-run', 'analyze + report, write nothing (prints report to stdout unless --report is given)')
+    .option('--diff', 'print unified diffs per changed file')
+    .option('--report <path>', 'report file (default: <outputPackDir>/optipack-report.json)')
+    .option('--lint <bool>', 'enable/disable the lint pass (true|false)', parseBoolOpt)
+    .action((inputDir, outputDir) => runOptimize(inputDir, outputDir, program.opts()));
+
+  try {
+    await program.parseAsync(argv, { from: 'node' });
+  } catch (e) {
+    if (e && e.code === 'commander.version') {
+      console.log(e.message);
+      return 0;
+    }
+    if (e && (e.code === 'commander.help' || e.code === 'commander.helpDisplayed')) {
+      return 0;
+    }
+    if (e && (e.code === 'commander.missingArgument' || e.code === 'commander.missingSubcommandArgument')) {
+      console.error(`optipack: ${e.message}`);
+      return 1;
+    }
+    console.error(`optipack: ${e && e.message ? e.message : String(e)}`);
+    return 1;
+  }
+  return process.exitCode ?? 0;
+}

package/src/config.js

@@ -0,0 +1,141 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const LEVELS = ['safe', 'balanced', 'risky'];
+export const LEVEL_RANK = { safe: 0, balanced: 1, risky: 2 };
+
+export const DEFAULT_CONFIG = {
+  level: 'balanced',
+  transforms: {},
+  hotPath: { transitiveDepth: 1 },
+  lint: true,
+};
+
+export class ConfigError extends Error {}
+
+function isPlainObject(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+function parseLevel(v) {
+  if (typeof v !== 'string' || !LEVELS.includes(v)) {
+    throw new ConfigError(`invalid level "${String(v)}" (expected one of ${LEVELS.join(', ')})`);
+  }
+  return v;
+}
+
+/**
+ * Validate a raw parsed config object and normalize it onto the defaults.
+ * Throws ConfigError on any structural problem.
+ */
+export function normalizeConfig(raw) {
+  if (raw === undefined || raw === null) return { ...DEFAULT_CONFIG, transforms: {}, hotPath: { transitiveDepth: 1 } };
+  if (!isPlainObject(raw)) throw new ConfigError('config root must be a JSON object');
+  const cfg = {
+    level: DEFAULT_CONFIG.level,
+    transforms: {},
+    hotPath: { transitiveDepth: 1 },
+    lint: true,
+  };
+  if (raw.level !== undefined) cfg.level = parseLevel(raw.level);
+  if (raw.lint !== undefined) {
+    if (typeof raw.lint !== 'boolean') throw new ConfigError('lint must be a boolean');
+    cfg.lint = raw.lint;
+  }
+  if (raw.transforms !== undefined) {
+    if (!isPlainObject(raw.transforms)) throw new ConfigError('transforms must be an object of booleans');
+    for (const [k, v] of Object.entries(raw.transforms)) {
+      if (typeof v !== 'boolean') throw new ConfigError(`transforms["${k}"] must be a boolean`);
+      cfg.transforms[k] = v;
+    }
+  }
+  if (raw.hotPath !== undefined) {
+    if (!isPlainObject(raw.hotPath)) throw new ConfigError('hotPath must be an object');
+    if (raw.hotPath.transitiveDepth !== undefined) {
+      const d = raw.hotPath.transitiveDepth;
+      if (typeof d !== 'number' || !Number.isInteger(d) || d < 0 || d > 10) {
+        throw new ConfigError('hotPath.transitiveDepth must be an integer between 0 and 10');
+      }
+      cfg.hotPath.transitiveDepth = d;
+    }
+    for (const k of Object.keys(raw.hotPath)) {
+      if (k !== 'transitiveDepth') throw new ConfigError(`unknown hotPath option "${k}"`);
+    }
+  }
+  for (const k of Object.keys(raw)) {
+    if (!['level', 'transforms', 'hotPath', 'lint'].includes(k)) {
+      throw new ConfigError(`unknown config key "${k}"`);
+    }
+  }
+  return cfg;
+}
+
+/**
+ * Load the config file. `explicitPath` wins; otherwise `./optipack.config.json`
+ * is used when present relative to cwd. Returns { config, path } where path is
+ * null when no file was found.
+ */
+export function loadConfigFile(explicitPath, cwd = process.cwd()) {
+  let file = explicitPath;
+  if (!file) {
+    const def = path.join(cwd, 'optipack.config.json');
+    if (fs.existsSync(def)) file = def;
+  }
+  if (!file) return { config: normalizeConfig(undefined), path: null };
+  let text;
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch (e) {
+    throw new ConfigError(`cannot read config file ${file}: ${e.message}`);
+  }
+  if (text.charCodeAt(0) === 0xfeff) text = text.slice(1); // tolerate BOM
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (e) {
+    throw new ConfigError(`config file ${file} is not valid JSON: ${e.message}`);
+  }
+  return { config: normalizeConfig(raw), path: file };
+}
+
+/**
+ * Merge CLI flags over a loaded config. CLI flags always win.
+ * Only recognized transform ids may appear in the transforms map; the caller
+ * passes the known id set (from the pass registry).
+ */
+export function mergeCliOverrides(config, cli, knownPassIds, knownPassCodes) {
+  const out = {
+    level: config.level,
+    transforms: { ...config.transforms },
+    hotPath: { ...config.hotPath },
+    lint: config.lint,
+  };
+  if (cli.level !== undefined) out.level = parseLevel(cli.level);
+  if (cli.config && cli.lint !== undefined) out.lint = cli.lint;
+  else if (!cli.config && cli.lint !== undefined) out.lint = cli.lint;
+
+  const normalizeList = (flag, list) => {
+    if (!list) return null;
+    const ids = list
+      .split(',')
+      .map((s) => s.trim())
+      .filter((s) => s.length > 0);
+    for (const id of ids) {
+      if (!knownPassIds.has(id) && !knownPassCodes.has(id)) {
+        throw new ConfigError(`unknown transform "${id}" in --${flag} (known: ${[...knownPassIds].join(', ')})`);
+      }
+    }
+    return ids;
+  };
+  const only = normalizeList('only', cli.only);
+  const except = normalizeList('except', cli.except);
+  if (except) {
+    for (const id of except) out.transforms[knownPassIds.has(id) ? id : knownPassCodes.get(id)] = false;
+  }
+  if (only) {
+    // --only replaces the enabled set entirely.
+    out.only = new Set(only.map((id) => (knownPassIds.has(id) ? id : knownPassCodes.get(id))));
+  }
+  if (cli.lint !== undefined) out.lint = cli.lint;
+  return out;
+}