optipack 0.0.0-stage → 1.0.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;
+}

package/src/diff.js

@@ -0,0 +1,108 @@
+/**
+ * Minimal dependency-free unified diff (line based, LCS). Deterministic.
+ * Used by `optipack --diff`.
+ */
+
+export function splitLines(text) {
+  const lines = text.split('\n');
+  // A trailing newline produces a final empty element; drop it for diffing.
+  if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();
+  return lines;
+}
+
+function lcsTable(a, b) {
+  const n = a.length;
+  const m = b.length;
+  const dp = new Array((n + 1) * (m + 1)).fill(0);
+  const at = (i, j) => dp[i * (m + 1) + j];
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      dp[i * (m + 1) + j] = a[i] === b[j] ? at(i + 1, j + 1) + 1 : Math.max(at(i + 1, j), at(i, j + 1));
+    }
+  }
+  return at;
+}
+
+/**
+ * Compute ops: [{type: 'eq'|'del'|'add', aLine, bLine, text}]
+ */
+export function diffLines(a, b) {
+  const A = splitLines(a);
+  const B = splitLines(b);
+  const at = lcsTable(A, B);
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < A.length && j < B.length) {
+    if (A[i] === B[j]) {
+      ops.push({ type: 'eq', aLine: i + 1, bLine: j + 1, text: A[i] });
+      i++; j++;
+    } else if (at(i + 1, j) >= at(i, j + 1)) {
+      ops.push({ type: 'del', aLine: i + 1, bLine: j + 1, text: A[i] });
+      i++;
+    } else {
+      ops.push({ type: 'add', aLine: i + 1, bLine: j + 1, text: B[j] });
+      j++;
+    }
+  }
+  while (i < A.length) ops.push({ type: 'del', aLine: i + 1, bLine: j + 1, text: A[i++] });
+  while (j < B.length) ops.push({ type: 'add', aLine: i + 1, bLine: j + 1, text: B[j++] });
+  return ops;
+}
+
+/**
+ * Render a unified diff for one file. Returns '' when there are no changes.
+ */
+export function unifiedDiff(fileA, fileB, aText, bText, contextLines = 3) {
+  const ops = diffLines(aText, bText);
+  if (ops.every((o) => o.type === 'eq')) return '';
+  const out = [];
+  out.push(`--- a/${fileA}`);
+  out.push(`+++ b/${fileB}`);
+  // Group into hunks.
+  let idx = 0;
+  while (idx < ops.length) {
+    if (ops[idx].type === 'eq') { idx++; continue; }
+    // Find hunk start: back up `contextLines` eq ops.
+    let start = idx;
+    let ctxBefore = 0;
+    while (start > 0 && ops[start - 1].type === 'eq' && ctxBefore < contextLines) { start--; ctxBefore++; }
+    // Extend hunk end while changes or within context of next change.
+    let end = idx;
+    let pendingEq = 0;
+    let k = idx;
+    while (k < ops.length) {
+      if (ops[k].type !== 'eq') { end = k; pendingEq = 0; k++; }
+      else {
+        pendingEq++;
+        if (pendingEq > contextLines * 2) break;
+        end = k;
+        k++;
+      }
+    }
+    // Trim trailing eq to contextLines.
+    let endTrim = end;
+    let ctxAfter = 0;
+    while (endTrim > start && ops[endTrim].type === 'eq' && ctxAfter < contextLines) { endTrim--; ctxAfter++; }
+    endTrim = Math.min(end, endTrim + (ops[endTrim] && ops[endTrim].type === 'eq' ? 0 : 0));
+    // hunk = ops[start..endTrim]
+    const hunk = ops.slice(start, endTrim + 1);
+    const aStart = hunk[0].aLine;
+    const bStart = hunk[0].bLine;
+    let aCount = 0;
+    let bCount = 0;
+    for (const o of hunk) {
+      if (o.type !== 'add') aCount++;
+      if (o.type !== 'del') bCount++;
+    }
+    out.push(`@@ -${aStart},${aCount} +${bStart},${bCount} @@`);
+    for (const o of hunk) {
+      if (o.type === 'eq') out.push(' ' + o.text);
+      else if (o.type === 'del') out.push('-' + o.text);
+      else out.push('+' + o.text);
+    }
+    idx = endTrim + 1;
+    while (idx < ops.length && ops[idx].type === 'eq') idx++;
+  }
+  return out.join('\n') + '\n';
+}

package/src/hotpath.js

@@ -0,0 +1,158 @@
+/**
+ * Hot-path classification and the shared pass context.
+ */
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+
+const _traverse = traverse.default || traverse;
+
+const HOT_CALLEE_NAMES = new Set(['runInterval', 'runTimeout', 'run', 'runJob', 'subscribe']);
+const TICK_CALLEE_NAMES = new Set(['runInterval', 'run']);
+
+function functionLike(node) {
+  return t.isFunctionDeclaration(node) || t.isFunctionExpression(node) || t.isArrowFunctionExpression(node);
+}
+
+/**
+ * Analyze the AST and classify functions as hot.
+ * Returns a HotInfo with:
+ *   isHot(node), isTick(node), hotCount, tickCount,
+ *   markHot(node), copyHotness(fromNode, toNode)
+ */
+export function analyzeHotPaths(ast, pragmas, { transitiveDepth = 1 } = {}) {
+  const hot = new WeakSet();
+  const tick = new WeakSet();
+  let hotCount = 0;
+  let tickCount = 0;
+
+  const addHot = (node, isTick) => {
+    if (!functionLike(node)) return;
+    if (!hot.has(node)) hotCount++;
+    hot.add(node);
+    if (isTick && !tick.has(node)) tickCount++;
+    if (isTick) tick.add(node);
+  };
+
+  // Resolve an argument that refers to a same-file function (by binding).
+  const resolveArg = (path, arg) => {
+    if (functionLike(arg)) return { node: arg, viaBinding: null };
+    if (t.isIdentifier(arg)) {
+      const binding = path.scope.getBinding(arg.name);
+      if (!binding) return null;
+      if (binding.path.isFunctionDeclaration()) return { node: binding.path.node, viaBinding: binding };
+      if (binding.path.isVariableDeclarator()) {
+        const init = binding.path.node.init;
+        if (functionLike(init)) return { node: init, viaBinding: binding };
+      }
+    }
+    return null;
+  };
+
+  // Pass 1: direct registration sites.
+  _traverse(ast, {
+    CallExpression(path) {
+      const callee = path.node.callee;
+      if (!t.isMemberExpression(callee) || callee.computed) return;
+      const prop = callee.property;
+      if (!t.isIdentifier(prop)) return;
+      if (prop.name === 'subscribe' || HOT_CALLEE_NAMES.has(prop.name)) {
+        const firstFn = path.node.arguments.find((a) => functionLike(a));
+        if (firstFn) {
+          addHot(firstFn, TICK_CALLEE_NAMES.has(prop.name));
+          return;
+        }
+        const arg = path.node.arguments[0];
+        if (!arg) return;
+        const r = resolveArg(path, arg);
+        if (r) addHot(r.node, TICK_CALLEE_NAMES.has(prop.name));
+      }
+    },
+  });
+
+  // Pass 1b: pragma hot marks.
+  _traverse(ast, {
+    'FunctionDeclaration|FunctionExpression|ArrowFunctionExpression'(path) {
+      const node = path.node;
+      if (node.loc && pragmas.isHotLine(node.loc.start.line)) addHot(node, false);
+    },
+  });
+
+  // Pass 2: transitive propagation through the same-file call graph.
+  // callGraph: targetNode -> Set of caller nodes (null = module top level)
+  // Also tracks reference sites for functions passed around as values.
+  const callersOf = new Map();
+  const recordCaller = (targetNode, callerNode) => {
+    if (!targetNode) return;
+    if (!callersOf.has(targetNode)) callersOf.set(targetNode, new Set());
+    callersOf.get(targetNode).add(callerNode);
+  };
+
+  const resolveCalleeNode = (path, callee) => {
+    if (!t.isIdentifier(callee)) return null;
+    if (callee.name === 'arguments' || callee.name === 'eval') return null;
+    const binding = path.scope.getBinding(callee.name);
+    if (!binding) return null;
+    if (binding.path.isFunctionDeclaration()) return binding.path.node;
+    if (binding.path.isVariableDeclarator()) {
+      const init = binding.path.node.init;
+      if (functionLike(init)) return init;
+    }
+    return null;
+  };
+
+  _traverse(ast, {
+    CallExpression(path) {
+      const target = resolveCalleeNode(path, path.node.callee);
+      if (target) recordCaller(target, path.getFunctionParent() ? path.getFunctionParent().node : null);
+    },
+    ReferencedIdentifier(path) {
+      // A function referenced as a value (e.g. passed to runInterval) counts as
+      // a use site within the enclosing function.
+      const binding = path.scope.getBinding(path.node.name);
+      if (!binding) return;
+      let target = null;
+      if (binding.path.isFunctionDeclaration()) target = binding.path.node;
+      else if (binding.path.isVariableDeclarator() && binding.path.node.init && functionLike(binding.path.node.init)) {
+        target = binding.path.node.init;
+      }
+      if (!target) return;
+      // Skip the declaration's own identifier.
+      if (binding.path.node.id === path.node || (binding.path.node.init && binding.path.node.init === path.node)) return;
+      recordCaller(target, path.getFunctionParent() ? path.getFunctionParent().node : null);
+    },
+  });
+
+  // BFS from the directly-hot set. A candidate becomes hot when every
+  // reference site is inside an already-hot function (i.e. it is only ever
+  // reached from hot code) and it has at least one reference site.
+  for (let depth = 0; depth < transitiveDepth; depth++) {
+    let changed = false;
+    for (const [target, callers] of callersOf) {
+      if (hot.has(target) || callers.size === 0) continue;
+      if (callers.has(null)) continue; // referenced at module top level
+      let allHot = true;
+      for (const c of callers) {
+        if (!hot.has(c)) { allHot = false; break; }
+      }
+      if (allHot) {
+        // Inherit tick-ness: if all callers are tick handlers, so is this.
+        let allTick = callers.size > 0;
+        for (const c of callers) if (!tick.has(c)) { allTick = false; break; }
+        addHot(target, allTick);
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+
+  return {
+    isHot: (node) => hot.has(node),
+    isTick: (node) => tick.has(node),
+    markHot: (node) => addHot(node, false),
+    copyHotness(fromNode, toNode) {
+      if (hot.has(fromNode)) addHot(toNode, tick.has(fromNode));
+    },
+    get hotCount() { return hotCount; },
+    get tickCount() { return tickCount; },
+  };
+}

package/src/lint.js

@@ -0,0 +1,150 @@
+/**
+ * Lint pass — reports anti-patterns with line numbers; never rewrites.
+ *
+ * Rules:
+ *  - per-tick-getAllPlayers   getAllPlayers()/getEntities()/dimension.players
+ *                             unconditionally inside per-tick callbacks
+ *  - dynprop-in-loop          getDynamicProperty inside tick loops beyond what
+ *                             B4 hoisted
+ *  - residual-allocs          closures/arrays/object literals remaining inside
+ *                             hot callbacks (GC pressure metric)
+ *  - subscribe-in-interval    subscribe() called inside runInterval handlers
+ *  - json-in-hot              JSON.parse/JSON.stringify/structuredClone in hot
+ *                             functions
+ *  - try-catch-wraps-tick     try/catch wrapping an entire tick-handler body
+ */
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import { walkSameFunction } from './pass-utils.js';
+
+const _traverse = traverse.default || traverse;
+
+export function runLint(programPath, ctx, hot) {
+  const fr = ctx.fileReport;
+
+  // ---- residual allocations inside hot functions (innermost attribution)
+  const counted = new WeakSet();
+  programPath.traverse({
+    'FunctionDeclaration|FunctionExpression|ArrowFunctionExpression'(path) {
+      const fn = path.node;
+      if (!ctx.isHot(fn)) return;
+      if (counted.has(fn)) return;
+      walkSameFunction(fn.body, (n) => {
+        if (n !== fn && (t.isFunctionExpression(n) || t.isArrowFunctionExpression(n))) {
+          if (counted.has(n)) return false; // attributed to the inner hot fn
+          if (ctx.isHot(n)) return true; // visited separately
+          if (n.loc) fr.residualAllocs.closures++;
+          counted.add(n);
+          return false;
+        }
+        if (t.isFunctionDeclaration(n) && n !== fn) {
+          counted.add(n);
+          return false;
+        }
+        if (n.loc && t.isArrayExpression(n)) fr.residualAllocs.arrays++;
+        else if (n.loc && t.isObjectExpression(n)) fr.residualAllocs.objects++;
+        return true;
+      });
+      counted.add(fn);
+    },
+  });
+
+  // ---- per-tick scan
+  programPath.traverse({
+    'FunctionDeclaration|FunctionExpression|ArrowFunctionExpression'(path) {
+      const fn = path.node;
+      if (!hot || !hot.isTick(fn)) return;
+      const line = fn.loc ? fn.loc.start.line : 0;
+
+      walkSameFunction(fn.body, (n) => {
+        // Rule 1: population sweeps in tick handlers.
+        if (t.isCallExpression(n) && t.isMemberExpression(n.callee) && !n.callee.computed &&
+            t.isIdentifier(n.callee.property)) {
+          const m = n.callee.property.name;
+          if (m === 'getAllPlayers' || m === 'getEntities') {
+            fr.lint.push({
+              line: n.loc ? n.loc.start.line : 0,
+              rule: 'per-tick-getAllPlayers',
+              message: `${m}() runs unconditionally inside a per-tick callback — prefer event-driven updates or caching between ticks`,
+            });
+          }
+          if (m === 'subscribe') {
+            fr.lint.push({
+              line: n.loc ? n.loc.start.line : 0,
+              rule: 'subscribe-in-interval',
+              message: 'subscribe() inside a per-tick handler re-registers on every tick — move registration to setup',
+            });
+          }
+          if (m === 'parse' && t.isMemberExpression(n.callee.object) &&
+              t.isIdentifier(n.callee.object.object, { name: 'JSON' })) {
+            fr.lint.push({
+              line: n.loc ? n.loc.start.line : 0,
+              rule: 'json-in-hot',
+              message: 'JSON.parse in a hot function — parse once at startup instead',
+            });
+          }
+        }
+        if (t.isMemberExpression(n) && !n.computed && t.isIdentifier(n.property) &&
+            n.property.name === 'players' && !isCallCallee(n)) {
+          // dimension.players — only flag when the object looks like a dimension
+          if (t.isIdentifier(n.object) && /dimension/i.test(n.object.name)) {
+            fr.lint.push({
+              line: n.loc ? n.loc.start.line : 0,
+              rule: 'per-tick-getAllPlayers',
+              message: 'dimension.players allocates a fresh array every read — cache or go event-driven',
+            });
+          }
+        }
+        if (t.isCallExpression(n) && t.isMemberExpression(n.callee) && !n.callee.computed &&
+            t.isIdentifier(n.callee.property) && n.callee.property.name === 'stringify' &&
+            t.isMemberExpression(n.callee.object) && t.isIdentifier(n.callee.object.object, { name: 'JSON' })) {
+          fr.lint.push({
+            line: n.loc ? n.loc.start.line : 0,
+            rule: 'json-in-hot',
+            message: 'JSON.stringify in a hot function — serialize only when data changes',
+          });
+        }
+        if (t.isCallExpression(n) && t.isIdentifier(n.callee) && n.callee.name === 'structuredClone') {
+          fr.lint.push({
+            line: n.loc ? n.loc.start.line : 0,
+            rule: 'json-in-hot',
+            message: 'structuredClone in a hot function — clones allocate every tick',
+          });
+        }
+        // Rule 2: remaining getDynamicProperty inside loops.
+        if ((t.isForStatement(n) || t.isWhileStatement(n) || t.isDoWhileStatement(n) ||
+             t.isForOfStatement(n) || t.isForInStatement(n))) {
+          walkSameFunction(n.body, (m) => {
+            if (t.isCallExpression(m) && t.isMemberExpression(m.callee) && !m.callee.computed &&
+                t.isIdentifier(m.callee.property) && m.callee.property.name === 'getDynamicProperty') {
+              fr.lint.push({
+                line: m.loc ? m.loc.start.line : 0,
+                rule: 'dynprop-in-loop',
+                message: 'getDynamicProperty inside a tick loop — reads cross the host boundary every iteration',
+              });
+            }
+            return true;
+          });
+        }
+        return true;
+      });
+
+      // Rule 6: try/catch wrapping the whole handler body.
+      if (t.isBlockStatement(fn.body) && fn.body.body.length === 1 &&
+          t.isTryStatement(fn.body.body[0])) {
+        fr.lint.push({
+          line: fn.body.body[0].loc ? fn.body.body[0].loc.start.line : line,
+          rule: 'try-catch-wraps-tick',
+          message: 'try/catch wraps the entire tick handler body — errors are swallowed every tick',
+        });
+      }
+    },
+  });
+}
+
+function isCallCallee(memberPathNode) {
+  // We walk nodes without paths here; a member expression that is a callee is
+  // handled by the CallExpression branch above, so treat all as non-callee.
+  void memberPathNode;
+  return false;
+}

package/src/pack-walker.js

@@ -0,0 +1,50 @@
+/**
+ * Pack walker — walks the input behavior pack, copies non-script files
+ * verbatim, and returns the list of script files to transform.
+ *
+ * Only files under `scripts/` with .js/.mjs extensions are transformed.
+ * node_modules/ and .git/ are skipped entirely. Everything else (manifest.json,
+ * JSON, functions, texts, textures) is copied byte-for-byte.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+const SCRIPT_EXT = new Set(['.js', '.mjs']);
+const SKIP_DIRS = new Set(['node_modules', '.git']);
+
+export function walkPack(inputDir) {
+  const scripts = [];
+  const copies = [];
+  const visit = (dir, rel) => {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const ent of entries) {
+      const abs = path.join(dir, ent.name);
+      const relPath = rel ? `${rel}/${ent.name}` : ent.name;
+      if (ent.isDirectory()) {
+        if (SKIP_DIRS.has(ent.name)) continue;
+        visit(abs, relPath);
+      } else if (ent.isFile()) {
+        const ext = path.extname(ent.name).toLowerCase();
+        const inScripts = relPath === 'scripts' || relPath.startsWith('scripts/');
+        if (inScripts && SCRIPT_EXT.has(ext)) {
+          scripts.push({ abs, relPath });
+        } else {
+          copies.push({ abs, relPath });
+        }
+      }
+    }
+  };
+  visit(inputDir, '');
+  return { scripts, copies };
+}
+
+export function copyFile(srcAbs, destAbs) {
+  fs.mkdirSync(path.dirname(destAbs), { recursive: true });
+  fs.copyFileSync(srcAbs, destAbs);
+}
+
+export function writeFile(destAbs, content) {
+  fs.mkdirSync(path.dirname(destAbs), { recursive: true });
+  fs.writeFileSync(destAbs, content);
+}