reverseport 0.0.0-stage → 1.2.0

package/port/src/formats.mjs

@@ -0,0 +1,229 @@
+// File-format identification by content (magic bytes), embedded-file signatures for carving,
+// entropy profiles and record-stride guesses for unknown formats.
+import fs from 'node:fs/promises';
+import { entropy, isText, MiB } from './util.mjs';
+
+const B = s => Buffer.from(s, 'latin1');
+const at = (buf, off, bytes) => off >= 0 && off + bytes.length <= buf.length && bytes.every((b, i) => buf[off + i] === b);
+const str = (buf, off, s) => off >= 0 && off + s.length <= buf.length && buf.toString('latin1', off, off + s.length) === s;
+const u32le = (buf, off) => (off + 4 <= buf.length ? buf.readUInt32LE(off) : -1);
+const u32be = (buf, off) => (off + 4 <= buf.length ? buf.readUInt32BE(off) : -1);
+
+/** Ordered: first match wins. category: executable | archive | engine | image | audio | video | model | font | data | document. */
+export const FORMATS = [
+  { id: 'elf', name: 'ELF executable/library', category: 'executable', test: (b, o) => at(b, o, [0x7f, 0x45, 0x4c, 0x46]) && [1, 2].includes(b[o + 4]) && [1, 2].includes(b[o + 5]) },
+  { id: 'pe', name: 'Windows PE executable/library (MZ)', category: 'executable', test: (b, o) => str(b, o, 'MZ') && (() => { const e = u32le(b, o + 0x3c); return e > 0 && e < 0x10000 && str(b, o + e, 'PE\0\0'); })() },
+  { id: 'macho', name: 'Mach-O executable/library', category: 'executable', test: (b, o) => [0xfeedface, 0xfeedfacf].includes(u32le(b, o)) || [0xfeedface, 0xfeedfacf].includes(u32be(b, o)) },
+  { id: 'java-class', name: 'Java class file', category: 'executable', test: (b, o) => u32be(b, o) === 0xcafebabe && u32be(b, o + 4) >= 45 },
+  { id: 'macho-fat', name: 'Mach-O universal (fat) binary', category: 'executable', test: (b, o) => (u32be(b, o) === 0xcafebabe || u32be(b, o) === 0xcafebabf) && u32be(b, o + 4) > 0 && u32be(b, o + 4) < 45 },
+  { id: 'wasm', name: 'WebAssembly module', category: 'executable', test: (b, o) => at(b, o, [0, 0x61, 0x73, 0x6d]) && u32le(b, o + 4) === 1 },
+  { id: 'dex', name: 'Android Dalvik bytecode (dex)', category: 'executable', test: (b, o) => str(b, o, 'dex\n') && b[o + 7] === 0 },
+  { id: 'lua-bytecode', name: 'Lua bytecode', category: 'executable', test: (b, o) => at(b, o, [0x1b, 0x4c, 0x75, 0x61]) },
+  { id: 'luajit-bytecode', name: 'LuaJIT bytecode', category: 'executable', test: (b, o) => at(b, o, [0x1b, 0x4c, 0x4a]) },
+  { id: 'pyc', name: 'Python bytecode (.pyc)', category: 'executable', offsetZeroOnly: true, test: (b, o) => o === 0 && b.length > 16 && b[2] === 0x0d && b[3] === 0x0a && b.readUInt16LE(0) > 3000 && b.readUInt16LE(0) < 4000 },
+  { id: 'godot-pck', name: 'Godot resource pack (GDPC)', category: 'engine', test: (b, o) => str(b, o, 'GDPC') && u32le(b, o + 4) >= 0 && u32le(b, o + 4) <= 3 },
+  { id: 'godot-resource', name: 'Godot binary resource (RSRC)', category: 'engine', test: (b, o) => str(b, o, 'RSRC') },
+  { id: 'godot-resource-compressed', name: 'Godot compressed resource (RSCC)', category: 'engine', test: (b, o) => str(b, o, 'RSCC') },
+  { id: 'godot-ctex', name: 'Godot 4 compressed texture (GST2)', category: 'engine', test: (b, o) => str(b, o, 'GST2') },
+  { id: 'godot-stex', name: 'Godot 3 stream texture (GDST)', category: 'engine', test: (b, o) => str(b, o, 'GDST') },
+  { id: 'unityfs', name: 'Unity asset bundle (UnityFS)', category: 'engine', test: (b, o) => str(b, o, 'UnityFS\0') },
+  { id: 'unity-web', name: 'Unity web/raw bundle', category: 'engine', test: (b, o) => str(b, o, 'UnityWeb\0') || str(b, o, 'UnityRaw\0') || str(b, o, 'UnityArchive') },
+  { id: 'il2cpp-metadata', name: 'Unity IL2CPP global-metadata', category: 'engine', test: (b, o) => u32le(b, o) === 0xfab11baf },
+  { id: 'unreal-asset', name: 'Unreal package (.uasset/.umap)', category: 'engine', test: (b, o) => u32le(b, o) === 0x9e2a83c1 },
+  { id: 'gamemaker-data', name: 'GameMaker data (FORM/GEN8)', category: 'engine', test: (b, o) => str(b, o, 'FORM') && str(b, o + 8, 'GEN8') },
+  { id: 'renpy-rpa', name: "Ren'Py archive (RPA)", category: 'archive', test: (b, o) => str(b, o, 'RPA-3.0 ') || str(b, o, 'RPA-2.0 ') },
+  { id: 'asar', name: 'Electron archive (asar)', category: 'archive', offsetZeroOnly: true, test: (b, o) => o === 0 && u32le(b, 0) === 4 && str(b, 16, '{"files"') },
+  { id: 'zip', name: 'ZIP archive (also apk/jar/ipa/docx/nupkg)', category: 'archive', test: (b, o) => at(b, o, [0x50, 0x4b, 3, 4]) || at(b, o, [0x50, 0x4b, 5, 6]) },
+  { id: 'gzip', name: 'gzip', category: 'archive', test: (b, o) => at(b, o, [0x1f, 0x8b, 8]) && b[o + 3] < 0x20 },
+  { id: '7z', name: '7-Zip archive', category: 'archive', test: (b, o) => at(b, o, [0x37, 0x7a, 0xbc, 0xaf, 0x27, 0x1c]) },
+  { id: 'rar', name: 'RAR archive', category: 'archive', test: (b, o) => str(b, o, 'Rar!\x1a\x07') },
+  { id: 'xz', name: 'xz', category: 'archive', test: (b, o) => at(b, o, [0xfd, 0x37, 0x7a, 0x58, 0x5a, 0]) },
+  { id: 'zstd', name: 'Zstandard frame', category: 'archive', test: (b, o) => at(b, o, [0x28, 0xb5, 0x2f, 0xfd]) },
+  { id: 'lz4', name: 'LZ4 frame', category: 'archive', test: (b, o) => at(b, o, [0x04, 0x22, 0x4d, 0x18]) },
+  { id: 'bzip2', name: 'bzip2', category: 'archive', test: (b, o) => str(b, o, 'BZh') && b[o + 3] >= 0x31 && b[o + 3] <= 0x39 },
+  { id: 'tar', name: 'tar archive', category: 'archive', test: (b, o) => str(b, o + 257, 'ustar') },
+  { id: 'ole', name: 'OLE compound file (msi/doc/xls)', category: 'archive', test: (b, o) => at(b, o, [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1]) },
+  { id: 'sqlite', name: 'SQLite database', category: 'data', test: (b, o) => str(b, o, 'SQLite format 3\0') },
+  { id: 'pdf', name: 'PDF document', category: 'document', test: (b, o) => str(b, o, '%PDF-') },
+  { id: 'png', name: 'PNG image', category: 'image', test: (b, o) => at(b, o, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]) },
+  { id: 'jpeg', name: 'JPEG image', category: 'image', test: (b, o) => at(b, o, [0xff, 0xd8, 0xff]) && [0xe0, 0xe1, 0xe2, 0xe8, 0xed, 0xee, 0xdb, 0xc0, 0xc2, 0xc4, 0xfe].includes(b[o + 3]) },
+  { id: 'gif', name: 'GIF image', category: 'image', test: (b, o) => str(b, o, 'GIF87a') || str(b, o, 'GIF89a') },
+  { id: 'webp', name: 'WebP image', category: 'image', test: (b, o) => str(b, o, 'RIFF') && str(b, o + 8, 'WEBP') },
+  { id: 'psd', name: 'Photoshop document', category: 'image', test: (b, o) => str(b, o, '8BPS') && b.length > o + 5 && b.readUInt16BE(o + 4) <= 2 },
+  { id: 'dds', name: 'DirectDraw Surface texture', category: 'image', test: (b, o) => str(b, o, 'DDS ') && u32le(b, o + 4) === 124 },
+  { id: 'ktx', name: 'KTX texture', category: 'image', test: (b, o) => at(b, o, [0xab, 0x4b, 0x54, 0x58, 0x20]) },
+  { id: 'exr', name: 'OpenEXR image', category: 'image', test: (b, o) => at(b, o, [0x76, 0x2f, 0x31, 0x01]) },
+  { id: 'hdr', name: 'Radiance HDR image', category: 'image', test: (b, o) => str(b, o, '#?RADIANCE') || str(b, o, '#?RGBE') },
+  { id: 'bmp', name: 'BMP image', category: 'image', offsetZeroOnly: true, test: (b, o) => o === 0 && str(b, 0, 'BM') && u32le(b, 14) >= 12 && u32le(b, 14) <= 124 },
+  { id: 'ico', name: 'Windows icon', category: 'image', offsetZeroOnly: true, test: (b, o) => o === 0 && at(b, 0, [0, 0, 1, 0]) && b.length > 6 && b.readUInt16LE(4) > 0 && b.readUInt16LE(4) < 64 },
+  { id: 'wav', name: 'WAVE audio', category: 'audio', test: (b, o) => str(b, o, 'RIFF') && str(b, o + 8, 'WAVE') },
+  { id: 'fmod-bank', name: 'FMOD Studio bank', category: 'audio', test: (b, o) => str(b, o, 'RIFF') && str(b, o + 8, 'FEV ') },
+  { id: 'avi', name: 'AVI video', category: 'video', test: (b, o) => str(b, o, 'RIFF') && str(b, o + 8, 'AVI ') },
+  { id: 'ogg', name: 'Ogg (Vorbis/Opus/Theora)', category: 'audio', test: (b, o) => str(b, o, 'OggS') && b[o + 4] === 0 },
+  { id: 'flac', name: 'FLAC audio', category: 'audio', test: (b, o) => str(b, o, 'fLaC') },
+  { id: 'mp3', name: 'MP3 audio (ID3)', category: 'audio', test: (b, o) => str(b, o, 'ID3') && b[o + 3] >= 2 && b[o + 3] <= 4 },
+  { id: 'wwise-bank', name: 'Wwise sound bank', category: 'audio', test: (b, o) => str(b, o, 'BKHD') },
+  { id: 'midi', name: 'MIDI', category: 'audio', test: (b, o) => str(b, o, 'MThd') && u32be(b, o + 4) === 6 },
+  { id: 'mp4', name: 'MP4/MOV video (ISO BMFF)', category: 'video', test: (b, o) => str(b, o + 4, 'ftyp') && /^[ -~]{4}$/.test(b.toString('latin1', o + 8, o + 12)) },
+  { id: 'matroska', name: 'Matroska/WebM video', category: 'video', test: (b, o) => at(b, o, [0x1a, 0x45, 0xdf, 0xa3]) },
+  { id: 'bink', name: 'Bink video', category: 'video', test: (b, o) => (str(b, o, 'BIK') && 'bdfghi'.includes(String.fromCharCode(b[o + 3]))) || str(b, o, 'KB2') },
+  { id: 'glb', name: 'glTF binary model (.glb)', category: 'model', test: (b, o) => str(b, o, 'glTF') && u32le(b, o + 4) === 2 },
+  { id: 'fbx', name: 'FBX binary model', category: 'model', test: (b, o) => str(b, o, 'Kaydara FBX Binary') },
+  { id: 'blend', name: 'Blender file', category: 'model', test: (b, o) => str(b, o, 'BLENDER') && '_-'.includes(String.fromCharCode(b[o + 7])) },
+  { id: 'otf', name: 'OpenType font (CFF)', category: 'font', test: (b, o) => str(b, o, 'OTTO') },
+  { id: 'woff', name: 'WOFF font', category: 'font', test: (b, o) => str(b, o, 'wOFF') },
+  { id: 'woff2', name: 'WOFF2 font', category: 'font', test: (b, o) => str(b, o, 'wOF2') },
+  { id: 'ttf', name: 'TrueType font', category: 'font', offsetZeroOnly: true, test: (b, o) => o === 0 && at(b, 0, [0, 1, 0, 0]) && b.length > 12 && b.readUInt16BE(4) > 0 && b.readUInt16BE(4) < 64 },
+];
+
+const TEXT_KINDS = [
+  { id: 'godot-scene', name: 'Godot text scene (.tscn)', re: /^\[gd_scene\b/ },
+  { id: 'godot-text-resource', name: 'Godot text resource (.tres)', re: /^\[gd_resource\b/ },
+  { id: 'godot-project', name: 'Godot project settings', re: /^; Engine configuration file/ },
+  { id: 'unity-yaml', name: 'Unity YAML asset (scene/prefab/asset)', re: /^%YAML[^\n]*\n%TAG !u! tag:unity3d\.com/ },
+  { id: 'yaml', name: 'YAML', re: /^(%YAML|---\s*\n)/ },
+  { id: 'xml', name: 'XML', re: /^\s*<\?xml/ },
+  { id: 'html', name: 'HTML', re: /^\s*<!doctype html|^\s*<html/i },
+  { id: 'json', name: 'JSON', re: /^\s*[[{]/ },
+  { id: 'obj', name: 'Wavefront OBJ (text model)', re: /^(#[^\n]*\n)*\s*(mtllib|o |v -?\d)/m },
+  { id: 'shebang-script', name: 'Script (shebang)', re: /^#!/ },
+];
+
+/** Identify a buffer that starts at the beginning of a file. */
+export function identify(head) {
+  for (const f of FORMATS) {
+    try { if (f.test(head, 0)) return { id: f.id, name: f.name, category: f.category }; } catch { /* short buffer */ }
+  }
+  if (isText(head)) {
+    const text = head.toString('utf8', 0, Math.min(head.length, 4096)).replace(/^/, '');
+    for (const k of TEXT_KINDS) if (k.re.test(text)) return { id: k.id, name: k.name, category: 'text' };
+    return { id: 'text', name: 'Plain text', category: 'text' };
+  }
+  return { id: 'unknown', name: 'Unknown binary data', category: 'unknown' };
+}
+
+/** Signatures worth looking for inside other files (distinctive enough to carve). */
+const CARVE = [
+  ['png', B('\x89PNG\r\n\x1a\n'), 0], ['jpeg', Buffer.from([0xff, 0xd8, 0xff]), 0], ['gif', B('GIF8'), 0],
+  ['ogg', B('OggS'), 0], ['wav', B('RIFF'), 0], ['flac', B('fLaC'), 0], ['mp4', B('ftyp'), 4], ['matroska', Buffer.from([0x1a, 0x45, 0xdf, 0xa3]), 0],
+  ['zip', Buffer.from([0x50, 0x4b, 3, 4]), 0], ['godot-pck', B('GDPC'), 0], ['godot-resource', B('RSRC'), 0], ['godot-ctex', B('GST2'), 0],
+  ['unityfs', B('UnityFS\0'), 0], ['glb', B('glTF'), 0], ['dds', B('DDS |'), 0], ['fbx', B('Kaydara FBX Binary'), 0],
+  ['sqlite', B('SQLite format 3\0'), 0], ['pdf', B('%PDF-'), 0], ['elf', B('\x7fELF'), 0], ['pe', B('MZ'), 0], ['wasm', B('\0asm'), 0],
+  ['wwise-bank', B('BKHD'), 0], ['otf', B('OTTO'), 0], ['woff', B('wOFF'), 0], ['woff2', B('wOF2'), 0], ['midi', B('MThd'), 0],
+  ['bink', B('BIK'), 0], ['psd', B('8BPS'), 0], ['blend', B('BLENDER'), 0], ['7z', Buffer.from([0x37, 0x7a, 0xbc, 0xaf, 0x27, 0x1c]), 0],
+  ['xz', Buffer.from([0xfd, 0x37, 0x7a, 0x58, 0x5a, 0]), 0], ['gzip', Buffer.from([0x1f, 0x8b, 8]), 0], ['lua-bytecode', Buffer.from([0x1b, 0x4c, 0x75, 0x61]), 0],
+];
+const FORMAT_BY_ID = new Map(FORMATS.map(f => [f.id, f]));
+
+/** Size of an embedded object when its header says so (RIFF, glb, PNG up to IEND). */
+function knownSize(id, buf, o) {
+  if (['wav', 'webp', 'avi', 'fmod-bank'].includes(id)) return u32le(buf, o + 4) + 8;
+  if (id === 'glb') return u32le(buf, o + 8);
+  if (id === 'png') { const end = buf.indexOf(B('IEND'), o + 8); return end > 0 ? end + 8 - o : null; }
+  return null;
+}
+
+/**
+ * Scan a byte range for embedded files. Reads in chunks, so it works on multi-GB packs.
+ * Returns [{offset, id, name, size?}] (offset 0 itself is skipped unless includeStart).
+ */
+export async function findSignatures(file, { start = 0, maxBytes = 512 * MiB, max = 200, includeStart = false } = {}) {
+  const st = await fs.stat(file);
+  const end = Math.min(st.size, start + maxBytes);
+  const fh = await fs.open(file, 'r');
+  const found = [];
+  const CHUNK = 8 * MiB, OVER = 1024;
+  try {
+    for (let pos = start; pos < end && found.length < max; pos += CHUNK) {
+      const len = Math.min(CHUNK + OVER, st.size - pos);
+      const buf = Buffer.alloc(len);
+      await fh.read(buf, 0, len, pos);
+      const limitIdx = Math.min(CHUNK, end - pos);
+      const hits = [];
+      for (const [id, needle, back] of CARVE) {
+        for (let i = buf.indexOf(needle, back); i !== -1 && i - back < limitIdx; i = buf.indexOf(needle, i + 1)) {
+          const o = i - back;
+          const abs = pos + o;
+          if (abs === 0 && !includeStart) continue;
+          let fmt = FORMAT_BY_ID.get(id);
+          if (id === 'wav') fmt = ['wav', 'webp', 'avi', 'fmod-bank'].map(x => FORMAT_BY_ID.get(x)).find(f => f.test(buf, o));
+          let ok = false;
+          try { ok = !!fmt && fmt.test(buf, o); } catch { ok = false; }
+          if (!ok) continue;
+          const size = knownSize(fmt.id, buf, o);
+          hits.push({ offset: abs, id: fmt.id, name: fmt.name, ...(size && size > 0 && abs + size <= st.size ? { size } : {}) });
+          if (hits.length > max * 4) break;
+        }
+      }
+      hits.sort((a, b) => a.offset - b.offset);
+      for (const h of hits) { if (found.length >= max) break; found.push(h); }
+    }
+  } finally { await fh.close(); }
+  return { scanned: end - start, fileSize: st.size, truncated: end < st.size || found.length >= max, hits: found };
+}
+
+/** Entropy per block, merged into readable segments. */
+export async function entropyProfile(file, { start = 0, maxBytes = 512 * MiB, blocks = 256 } = {}) {
+  const st = await fs.stat(file);
+  const end = Math.min(st.size, start + maxBytes);
+  const span = end - start;
+  if (span <= 0) return { segments: [], average: 0 };
+  const n = Math.max(1, Math.min(blocks, Math.ceil(span / 4096)));
+  const blockSize = Math.ceil(span / n);
+  const sample = Math.min(blockSize, 64 * 1024);
+  const fh = await fs.open(file, 'r');
+  const values = [];
+  try {
+    for (let i = 0; i < n; i++) {
+      const off = start + i * blockSize;
+      if (off >= end) break;
+      const buf = Buffer.alloc(Math.min(sample, end - off));
+      await fh.read(buf, 0, buf.length, off);
+      values.push({ offset: off, length: Math.min(blockSize, end - off), entropy: entropy(buf) });
+    }
+  } finally { await fh.close(); }
+  const cls = e => (e < 1 ? 'empty/padding' : e < 4.5 ? 'structured/text' : e < 6.5 ? 'code/mixed' : e < 7.5 ? 'dense data' : 'compressed/encrypted');
+  const segments = [];
+  for (const v of values) {
+    const c = cls(v.entropy);
+    const last = segments[segments.length - 1];
+    if (last && last.class === c) { last.length += v.length; last.sum += v.entropy * v.length; }
+    else segments.push({ offset: v.offset, length: v.length, class: c, sum: v.entropy * v.length });
+  }
+  const average = values.reduce((s, v) => s + v.entropy * v.length, 0) / values.reduce((s, v) => s + v.length, 0);
+  return {
+    blockSize,
+    average: Math.round(average * 100) / 100,
+    segments: segments.slice(0, 64).map(s => ({ offset: s.offset, length: s.length, class: s.class, entropy: Math.round((s.sum / s.length) * 100) / 100 })),
+  };
+}
+
+/** Guess fixed-size record layouts: strides where bytes repeat far more often than chance. */
+export function strideGuess(buf, { min = 2, max = 1024 } = {}) {
+  const n = Math.min(buf.length, 65536);
+  if (n < 64) return [];
+  const counts = new Uint32Array(256);
+  for (let i = 0; i < n; i++) counts[buf[i]]++;
+  let baseline = 0;
+  for (const c of counts) baseline += (c / n) ** 2;
+  if (baseline > 0.5) return []; // mostly one value: padding, not records
+  const scores = [];
+  for (let s = min; s <= Math.min(max, n >> 2); s++) {
+    let same = 0;
+    for (let i = 0; i + s < n; i++) if (buf[i] === buf[i + s]) same++;
+    const score = same / (n - s) / baseline;
+    if (score > 1.6) scores.push({ stride: s, score: Math.round(score * 100) / 100 });
+  }
+  const byStride = new Map(scores.map(x => [x.stride, x]));
+  // A table with record size 24 also repeats at 48, 72…: report the smallest stride that scores nearly as well.
+  const base = x => { for (let d = min; d < x.stride; d++) if (x.stride % d === 0 && byStride.get(d)?.score >= x.score * 0.8) return byStride.get(d); return x; };
+  scores.sort((a, b) => b.score - a.score);
+  const picked = [];
+  for (const s of scores) {
+    const b = base(s);
+    if (picked.some(p => p.stride === b.stride || (b.stride % p.stride === 0 && b.score < p.score * 1.15))) continue;
+    picked.push(b);
+    if (picked.length >= 5) break;
+  }
+  return picked;
+}

package/port/src/graph.mjs

@@ -0,0 +1,275 @@
+// Dependency graph across a whole project: imports/includes/requires, Godot res:// loads and scene
+// resources, Unity script/prefab GUIDs, and type references for languages without file imports (C#,
+// GDScript class_name, Java…). Gives cycles, entry points, orphans and a port order (dependencies first).
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { requireDir, walk, isText } from './util.mjs';
+import { languageOf, fileSymbols, stripComments, identifiers, CODE_LANGUAGES } from './symbols.mjs';
+import { unityGuidMap } from './scene.mjs';
+import { detectEngines } from './scan.mjs';
+
+const JS_EXT = ['.ts', '.tsx', '.mts', '.js', '.mjs', '.cjs', '.jsx', '.vue', '.svelte', '.json'];
+const TYPE_INDEX_LANGS = new Set(['csharp', 'java', 'kotlin', 'gdscript', 'swift', 'haxe', 'dart', 'scala']);
+const SCENE_LANGS = new Set(['godot-scene', 'godot-resource', 'unity-scene', 'unity-prefab']);
+
+export async function buildGraph(dir, { maxFiles = 30000 } = {}) {
+  const root = await requireDir(dir, 'project folder');
+  const { files, truncated, unreadable } = await walk(root, { maxFiles });
+  const byRel = new Map(files.map(f => [f.rel, f]));
+  const lowerRel = new Map(files.map(f => [f.rel.toLowerCase(), f.rel]));
+  const exists = rel => (byRel.has(rel) ? rel : lowerRel.get(rel.toLowerCase()) ?? null);
+  const engines = await detectEngines(root, files);
+  const godotRoots = engines.filter(e => e.id === 'godot').map(e => e.root).sort((a, b) => b.length - a.length);
+  const unityRoots = engines.filter(e => e.id === 'unity').map(e => e.root);
+  const godotRootOf = rel => godotRoots.find(r => !r || rel.startsWith(`${r}/`)) ?? '';
+  const nodes = new Map();
+  const externals = new Map();
+  const edges = [];
+  const edgeSet = new Set();
+  const addEdge = (from, to, kind) => { if (!to || from === to) return; const k = `${from}\0${to}`; if (edgeSet.has(k)) return; edgeSet.add(k); edges.push({ from, to, kind }); };
+  const external = spec => externals.set(spec, (externals.get(spec) ?? 0) + 1);
+
+  // Header index for C/C++ includes; package dirs for Go
+  const headers = new Map();
+  for (const f of files) if (/\.(h|hh|hpp|hxx|inl|h\.in)$/i.test(f.rel)) { const b = path.posix.basename(f.rel).toLowerCase(); headers.set(b, [...(headers.get(b) ?? []), f.rel]); }
+  let goModule = null;
+  if (byRel.has('go.mod')) goModule = (await fs.readFile(byRel.get('go.mod').abs, 'utf8')).match(/^module\s+(\S+)/m)?.[1] ?? null;
+
+  const typeIndex = new Map();
+  const identCache = new Map();
+  for (const e of engines.filter(x => x.id === 'godot')) for (const a of e.details.autoload) {
+    const rel = exists((e.root ? `${e.root}/` : '') + a.path.replace(/^res:\/\//, ''));
+    if (rel && /^[A-Z_]\w{2,}$/.test(a.name)) typeIndex.set(a.name, [rel]);
+  }
+  for (const f of files) {
+    const language = languageOf(f.rel);
+    if (!language || (!CODE_LANGUAGES.has(language) && !SCENE_LANGS.has(language))) continue;
+    if (f.size > 4 * 1024 * 1024) { nodes.set(f.rel, { file: f.rel, language, size: f.size, skipped: 'too large' }); continue; }
+    if (SCENE_LANGS.has(language)) { nodes.set(f.rel, { file: f.rel, language, size: f.size, kind: 'scene' }); continue; }
+    const sym = await fileSymbols(f.abs, language);
+    if (!sym) continue;
+    nodes.set(f.rel, { file: f.rel, language, size: f.size, lines: sym.lines, sym });
+    if (TYPE_INDEX_LANGS.has(language)) {
+      for (const c of sym.classes) if (c.name && !c.inner && c.name.length >= 3) typeIndex.set(c.name, [...(typeIndex.get(c.name) ?? []), f.rel]);
+      const text = await fs.readFile(f.abs, 'utf8');
+      identCache.set(f.rel, identifiers(stripComments(text, language)));
+    }
+  }
+
+  const resolveRes = (from, spec) => {
+    if (/^(uid|user):\/\//.test(spec)) return null;
+    if (spec.startsWith('res://')) { const r = godotRootOf(from); return exists(path.posix.normalize((r ? `${r}/` : '') + spec.slice(6))); }
+    return exists(path.posix.normalize(path.posix.join(path.posix.dirname(from), spec)));
+  };
+  const resolveJs = (from, spec) => {
+    if (!/^\.{1,2}\//.test(spec) && !spec.startsWith('/')) return null;
+    const base = spec.startsWith('/') ? spec.slice(1) : path.posix.normalize(path.posix.join(path.posix.dirname(from), spec));
+    const stem = base.replace(/\.(m?js|cjs|jsx)$/, '');
+    for (const c of [base, ...JS_EXT.map(e => stem + e), ...JS_EXT.map(e => `${base}/index${e}`)]) { const hit = exists(c); if (hit && hit !== from) return hit; }
+    return null;
+  };
+  const resolvePy = (from, spec) => {
+    const dots = spec.match(/^\.*/)[0].length;
+    const mod = spec.slice(dots).replace(/\./g, '/');
+    const bases = dots ? [path.posix.join(path.posix.dirname(from), ...Array(Math.max(0, dots - 1)).fill('..'))] : ['', 'src', path.posix.dirname(from)];
+    for (const b of bases) for (const c of [mod ? `${mod}.py` : '__init__.py', mod ? `${mod}/__init__.py` : null]) { if (!c) continue; const hit = exists(path.posix.normalize(b ? `${b}/${c}` : c)); if (hit) return hit; }
+    return null;
+  };
+  const resolveInclude = (from, spec) => {
+    const direct = exists(path.posix.normalize(path.posix.join(path.posix.dirname(from), spec))) ?? exists(spec);
+    if (direct) return direct;
+    const cands = (headers.get(path.posix.basename(spec).toLowerCase()) ?? []).filter(h => h.toLowerCase().endsWith(spec.toLowerCase()));
+    if (cands.length <= 1) return cands[0] ?? null;
+    const dirFrom = path.posix.dirname(from);
+    return cands.sort((a, b) => commonPrefix(b, dirFrom) - commonPrefix(a, dirFrom))[0];
+  };
+  const resolveLua = (from, spec) => {
+    const p = spec.replace(/\./g, '/');
+    for (const b of ['', path.posix.dirname(from)]) for (const c of [`${p}.lua`, `${p}/init.lua`]) { const hit = exists(path.posix.normalize(b ? `${b}/${c}` : c)); if (hit) return hit; }
+    return null;
+  };
+  const resolveRustMod = (from, name) => {
+    const dir = path.posix.dirname(from), stem = path.posix.basename(from, '.rs');
+    const base = ['mod', 'main', 'lib'].includes(stem) ? dir : path.posix.join(dir, stem);
+    return exists(path.posix.normalize(`${base}/${name}.rs`)) ?? exists(path.posix.normalize(`${base}/${name}/mod.rs`));
+  };
+
+  for (const n of nodes.values()) {
+    if (n.kind === 'scene') {
+      const text = await fs.readFile(byRel.get(n.file).abs, 'utf8').catch(() => '');
+      if (n.language.startsWith('godot')) {
+        for (const m of text.matchAll(/\[ext_resource[^\]]*?path="([^"]+)"/g)) { const hit = resolveRes(n.file, m[1]); if (hit) addEdge(n.file, hit, 'resource'); }
+      } else {
+        const uroot = unityRoots.find(r => !r || n.file.startsWith(`${r}/`));
+        const guids = await unityGuidMap(path.join(root, uroot ?? ''));
+        for (const g of new Set([...text.matchAll(/guid:\s*([0-9a-f]{32})/g)].map(m => m[1]))) {
+          const asset = guids.get(g);
+          const rel = asset && exists((uroot ? `${uroot}/` : '') + asset);
+          if (rel && (rel.endsWith('.cs') || /\.(prefab|unity|asset)$/.test(rel))) addEdge(n.file, rel, rel.endsWith('.cs') ? 'script' : 'asset');
+        }
+      }
+      continue;
+    }
+    if (!n.sym) continue;
+    for (const d of n.sym.deps) {
+      let hit = null;
+      switch (n.language) {
+        case 'gdscript': case 'shader': hit = resolveRes(n.file, d.spec); break;
+        case 'javascript': case 'typescript': hit = resolveJs(n.file, d.spec); if (!hit && !/^[./]/.test(d.spec)) external(d.spec.startsWith('@') ? d.spec.split('/').slice(0, 2).join('/') : d.spec.split('/')[0]); break;
+        case 'python': hit = resolvePy(n.file, d.spec); if (!hit && !d.spec.startsWith('.')) external(d.spec.split('.')[0]); break;
+        case 'c': case 'c-header': case 'cpp': case 'objc': if (d.kind === 'system') external(`<${d.spec}>`); else { hit = resolveInclude(n.file, d.spec); if (!hit) external(`"${d.spec}"`); } break;
+        case 'lua': hit = resolveLua(n.file, d.spec); if (!hit) external(d.spec); break;
+        case 'rust': if (d.kind === 'mod') hit = resolveRustMod(n.file, d.spec); else if (!/^(crate|self|super)::/.test(d.spec)) external(d.spec.split('::')[0]); break;
+        case 'go':
+          if (goModule && d.spec.startsWith(`${goModule}/`)) {
+            const pkgDir = d.spec.slice(goModule.length + 1);
+            for (const f of files) if (path.posix.dirname(f.rel) === pkgDir && f.rel.endsWith('.go') && !f.rel.endsWith('_test.go')) addEdge(n.file, f.rel, 'import');
+          } else external(d.spec);
+          break;
+        case 'java': case 'kotlin': case 'scala': {
+          const cls = d.spec.split('.').pop();
+          const cands = (typeIndex.get(cls) ?? []).filter(f => f.replace(/\.(java|kt|scala)$/, '').endsWith(d.spec.replace(/\./g, '/')));
+          if (cands[0]) hit = cands[0]; else if (cls !== '*') external(d.spec.split('.').slice(0, 2).join('.'));
+          break;
+        }
+        case 'csharp': external(d.spec.split('.').slice(0, 2).join('.')); break;
+        default: break;
+      }
+      if (hit) addEdge(n.file, hit, d.kind ?? 'import');
+    }
+  }
+  // Type references (C#, GDScript class_name, Java/Kotlin same-package, Swift…)
+  for (const [file, ids] of identCache) {
+    for (const id of ids) {
+      const owners = typeIndex.get(id);
+      if (!owners || owners.length > 3) continue;
+      for (const o of owners) if (o !== file) addEdge(file, o, 'type');
+    }
+  }
+
+  // Entry points
+  const entry = new Set();
+  for (const e of engines) {
+    if (e.id === 'godot') {
+      const base = e.root ? `${e.root}/` : '';
+      if (e.details.mainScene) { const r = exists(base + e.details.mainScene.replace(/^res:\/\//, '')); if (r) entry.add(r); }
+      for (const a of e.details.autoload) { const r = exists(base + a.path.replace(/^res:\/\//, '')); if (r) entry.add(r); }
+    }
+    if (e.id === 'unity') for (const s of e.details.buildScenes) { const r = exists((e.root ? `${e.root}/` : '') + s); if (r) entry.add(r); }
+    if (e.id === 'node') for (const m of [e.details.main, ...(e.details.starts ?? [])].filter(Boolean)) { const r = exists(path.posix.normalize((e.root ? `${e.root}/` : '') + m)); if (r) entry.add(r); }
+  }
+  for (const n of nodes.values()) if (n.sym?.entry || /(^|\/)(main\.(rs|go|py|c|cpp|cc|lua)|__main__\.py|Program\.cs)$/.test(n.file)) entry.add(n.file);
+
+  const out = new Map([...nodes.keys()].map(k => [k, []]));
+  const inc = new Map([...nodes.keys()].map(k => [k, 0]));
+  for (const e of edges) { if (!out.has(e.from) || !nodes.has(e.to)) continue; out.get(e.from).push(e.to); inc.set(e.to, inc.get(e.to) + 1); }
+  const { sccs, order } = tarjanOrder([...nodes.keys()], out);
+  const cycles = sccs.filter(c => c.length > 1).sort((a, b) => b.length - a.length);
+  const orphans = [...nodes.keys()].filter(k => !inc.get(k) && !entry.has(k) && nodes.get(k).kind !== 'scene' && !(out.get(k).length));
+  return { root, truncated, unreadable, engines, nodes, edges: edges.filter(e => nodes.has(e.to)), externals, cycles, order, entryPoints: [...entry], orphans, inDegree: inc, outEdges: out };
+}
+
+function commonPrefix(a, b) { let i = 0; while (i < a.length && i < b.length && a[i] === b[i]) i++; return i; }
+
+/** Strongly connected components (iterative Tarjan) + an order where dependencies come before dependents. */
+export function tarjanOrder(keys, out) {
+  let index = 0;
+  const idx = new Map(), low = new Map(), onStack = new Set(), stack = [], sccs = [];
+  for (const start of keys) {
+    if (idx.has(start)) continue;
+    const work = [[start, 0]];
+    idx.set(start, index); low.set(start, index); index++; stack.push(start); onStack.add(start);
+    while (work.length) {
+      const top = work[work.length - 1];
+      const [v, i] = top;
+      const next = out.get(v) ?? [];
+      if (i < next.length) {
+        top[1]++;
+        const w = next[i];
+        if (!out.has(w)) continue;
+        if (!idx.has(w)) { idx.set(w, index); low.set(w, index); index++; stack.push(w); onStack.add(w); work.push([w, 0]); }
+        else if (onStack.has(w)) low.set(v, Math.min(low.get(v), idx.get(w)));
+      } else {
+        work.pop();
+        if (work.length) { const u = work[work.length - 1][0]; low.set(u, Math.min(low.get(u), low.get(v))); }
+        if (low.get(v) === idx.get(v)) {
+          const comp = [];
+          let w;
+          do { w = stack.pop(); onStack.delete(w); comp.push(w); } while (w !== v);
+          sccs.push(comp.sort());
+        }
+      }
+    }
+  }
+  // Tarjan emits SCCs in reverse topological order of the condensation: a component comes after the ones
+  // it depends on. With edges pointing from user to dependency, that is exactly "dependencies first".
+  return { sccs, order: sccs.flat() };
+}
+
+export function graphMermaid(graph, max = 60) {
+  const score = k => (graph.inDegree.get(k) ?? 0) + (graph.outEdges.get(k)?.length ?? 0);
+  const keep = [...graph.nodes.keys()].sort((a, b) => score(b) - score(a)).slice(0, max);
+  const id = new Map(keep.map((k, i) => [k, `f${i}`]));
+  const lines = ['graph LR'];
+  for (const k of keep) lines.push(`  ${id.get(k)}["${path.posix.basename(k).replace(/"/g, "'")}"]`);
+  let shown = 0;
+  for (const e of graph.edges) {
+    if (!id.has(e.from) || !id.has(e.to)) continue;
+    lines.push(`  ${id.get(e.from)} --> ${id.get(e.to)}`);
+    if (++shown > 250) break;
+  }
+  return lines.join('\n');
+}
+
+export async function graphTool({ path: dir, limit, format = 'json' } = {}) {
+  const g = await buildGraph(dir);
+  // Small by default (portOrder and mostUsed already summarise the edges); an explicit limit asks for more.
+  const max = limit === undefined ? 80 : Math.max(10, Math.min(5000, limit));
+  const edgeMax = limit === undefined ? 40 : max * 3;
+  const files = [...g.nodes.values()].map(n => ({ file: n.file, language: n.language, ...(n.lines != null ? { lines: n.lines } : {}), dependsOn: g.outEdges.get(n.file).length, usedBy: g.inDegree.get(n.file) }));
+  files.sort((a, b) => b.usedBy - a.usedBy || b.dependsOn - a.dependsOn);
+  const ext = [...g.externals.entries()].sort((a, b) => b[1] - a[1]).slice(0, 50).map(([name, uses]) => ({ name, uses }));
+  return {
+    root: g.root, truncated: g.truncated, ...(g.unreadable?.length ? { unreadable: g.unreadable, warnings: [`${g.unreadable.length} folder(s) could not be read; the graph does not cover them.`] } : {}), fileCount: g.nodes.size, edgeCount: g.edges.length,
+    entryPoints: g.entryPoints, cycles: g.cycles.slice(0, 20).map(c => c.slice(0, 30)), orphans: g.orphans.slice(0, 100),
+    mostUsed: files.slice(0, 25), externals: ext,
+    portOrder: g.order.slice(0, max), portOrderTruncated: g.order.length > max,
+    edges: g.edges.slice(0, edgeMax), edgesTruncated: g.edges.length > edgeMax,
+    ...(format === 'mermaid' || format === 'both' ? { mermaid: graphMermaid(g) } : {}),
+    next: g.edges.length > edgeMax
+      ? `Showing ${edgeMax} of ${g.edges.length} edges and ${Math.min(max, g.order.length)} of ${g.order.length} files in portOrder. More: re_graph ${JSON.stringify({ path: g.root, limit: Math.min(5000, Math.max(max * 2, 400)) })}. One area: re_symbols ${JSON.stringify({ path: g.root, match: '<name>' })}. To port: port_plan ${JSON.stringify({ source: g.root, to: '<engine>' })}.`
+      : `One area: re_symbols ${JSON.stringify({ path: g.root, match: '<name>' })}. To port: port_plan ${JSON.stringify({ source: g.root, to: '<engine>' })}.`,
+  };
+}
+
+export async function symbolsTool({ path: target, match, limit = 60 } = {}) {
+  const st = await fs.stat(path.resolve(target ?? '')).catch(() => null);
+  if (st?.isFile()) {
+    const abs = path.resolve(target);
+    const buf = await fs.readFile(abs);
+    if (!isText(buf)) return { file: abs, error: 'binary file — use re_binary' };
+    const sym = await fileSymbols(abs);
+    if (!sym) return { file: abs, language: languageOf(abs), note: 'Not a recognised code file. Scenes: re_scene.' };
+    return { file: abs, ...sym };
+  }
+  const g = await buildGraph(target);
+  const want = match ? new RegExp(match.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*'), 'i') : null;
+  const out = [];
+  let classes = 0, functions = 0;
+  for (const n of g.nodes.values()) {
+    if (!n.sym) continue;
+    classes += n.sym.classes.length; functions += n.sym.functions.length;
+    const cls = n.sym.classes.filter(c => !want || want.test(c.name ?? '')).map(c => c.name ?? `(script extends ${c.extends})`);
+    const fns = n.sym.functions.filter(f => !want || want.test(f.name)).map(f => f.name);
+    if (want && !cls.length && !fns.length && !want.test(n.file)) continue;
+    if (!want && !cls.length && !fns.length && !n.sym.signals?.length) continue; // nothing to show for this file
+    out.push({ file: n.file, language: n.language, lines: n.lines, classes: cls.slice(0, 50), functions: fns.slice(0, 120), ...(n.sym.signals?.length ? { signals: n.sym.signals.map(s => s.name) } : {}), ...(n.sym.exports?.length ? { exported: n.sym.exports.slice(0, 50) } : {}), ...(n.sym.unreal ? { unreal: n.sym.unreal } : {}) });
+  }
+  const max = Math.max(1, Math.min(5000, limit));
+  const truncated = out.length > max;
+  return {
+    root: g.root, files: out.length, totalFiles: g.nodes.size, totalClasses: classes, totalFunctions: functions, ...(want ? { match } : {}),
+    items: out.slice(0, max), truncated,
+    ...(truncated || !out.length ? { next: !out.length ? `Nothing matched. Try a broader match, or re_graph ${JSON.stringify({ path: g.root })} for the structure.` : `Showing ${max} of ${out.length} files. Narrow it: re_symbols ${JSON.stringify({ path: g.root, match: '<name or *pattern*>' })} or point path at a subfolder.` } : {}),
+  };
+}

package/port/src/knowledge.mjs

@@ -0,0 +1,90 @@
+// Porting knowledge: engine conventions and API maps (knowledge/maps/*.json) plus helpers that find
+// which mapped APIs a source file uses and which source-engine leftovers remain in ported code.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { RPError } from './util.mjs';
+import { closest } from './agent.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'knowledge');
+export const ENGINES = JSON.parse(fs.readFileSync(path.join(ROOT, 'engines.json'), 'utf8'));
+const MAPS = new Map();
+for (const f of fs.readdirSync(path.join(ROOT, 'maps')).filter(f => f.endsWith('.json')).sort()) {
+  const m = JSON.parse(fs.readFileSync(path.join(ROOT, 'maps', f), 'utf8'));
+  for (const e of m.entries) {
+    if (e.pattern) e.re = new RegExp(e.pattern, 'gm');
+    if (e.leftover) e.leftoverRe = new RegExp(e.leftover, 'gm');
+  }
+  MAPS.set(`${m.from}->${m.to}`, m);
+}
+
+const ALIASES = {
+  gdscript: 'godot', 'godot4': 'godot', 'godot 4': 'godot', 'godot-gdscript': 'godot',
+  'godot-c#': 'godot-csharp', 'godot-cs': 'godot-csharp', 'godot.net': 'godot-csharp', 'godot-net': 'godot-csharp', 'godot-dotnet': 'godot-csharp',
+  three: 'threejs', 'three.js': 'threejs', web: 'threejs', browser: 'threejs', webgl: 'threejs',
+  ue: 'unreal', ue5: 'unreal', ue4: 'unreal', unreal5: 'unreal', unreal4: 'unreal', 'unreal 5': 'unreal', 'unreal engine': 'unreal', 'unreal-engine': 'unreal', 'unreal engine 5': 'unreal',
+  godot3: 'godot', 'godot 3': 'godot', threejs: 'threejs', 'unity 6': 'unity', unity6: 'unity',
+  'unity3d': 'unity', 'unity-csharp': 'unity',
+};
+export const normEngine = e => { const k = String(e ?? '').trim().toLowerCase(); return ALIASES[k] ?? k; };
+export const mapPairs = () => [...MAPS.keys()];
+export function mapFor(from, to) { return MAPS.get(`${normEngine(from)}->${normEngine(to)}`) ?? null; }
+
+export function portMapTool({ from, to, query, topic } = {}) {
+  if (!from && !to) return { engines: Object.fromEntries(Object.entries(ENGINES).map(([k, v]) => [k, v.name])), maps: mapPairs().map(p => { const m = MAPS.get(p); return { pair: p, title: m.title, entries: m.entries.length }; }), hint: 'Give from and to (e.g. {from:"godot", to:"unity"}) for the full map; query filters entries.' };
+  const a = normEngine(from), b = normEngine(to);
+  const map = mapFor(a, b);
+  if (!map) {
+    for (const [given, id] of [[from, a], [to, b]]) {
+      if (ENGINES[id] || !given) continue;
+      const near = closest(id, Object.keys(ENGINES), 3);
+      if (near && (ENGINES[a] || ENGINES[b] || near)) throw new RPError('INVALID_ARGUMENT', `Unknown engine "${given}" — did you mean "${near}"? Engines: ${Object.keys(ENGINES).join(', ')}; anything else is treated as a language.`);
+    }
+    if (!ENGINES[a] && !ENGINES[b]) return { from: a, to: b, note: 'No engine map for this pair: treat it as a language/framework port. Plan with port_plan; the unit checklist covers structure, idioms and parity.', available: mapPairs() };
+    return { from: a, to: b, fromConventions: ENGINES[a] ?? null, toConventions: ENGINES[b] ?? null, note: 'No curated API map for this pair yet; conventions of both sides are given. Available maps: ' + mapPairs().join(', ') };
+  }
+  const q = query ? String(query).toLowerCase() : null;
+  const entries = map.entries.filter(e => (!topic || e.topic === topic) && (!q || `${e.id} ${e.topic} ${e.from} ${e.to} ${e.notes ?? ''}`.toLowerCase().includes(q))).map(({ re, leftoverRe, pattern, leftover, ...e }) => e);
+  return { title: map.title, from: a, to: b, fromEngine: ENGINES[a] ?? null, toEngine: ENGINES[b] ?? null, conventions: map.conventions, topics: [...new Set(map.entries.map(e => e.topic))], entries, ...(!q && !topic ? { hint: 'This is the whole map; query or topic narrows it (e.g. {query:"signal"}). port_unit already lists the entries a file uses.' } : {}) };
+}
+
+/** Which mapped APIs does this source text use? */
+export function apiHits(text, from, to) {
+  const map = mapFor(from, to);
+  if (!map) return [];
+  const lineOf = idx => text.slice(0, idx).split('\n').length;
+  const hits = [];
+  for (const e of map.entries) {
+    if (!e.re) continue;
+    e.re.lastIndex = 0;
+    const at = [];
+    let m;
+    while ((m = e.re.exec(text)) && at.length < 50) { at.push(lineOf(m.index)); if (m[0] === '') e.re.lastIndex++; }
+    if (at.length) hits.push({ id: e.id, topic: e.topic, from: e.from, to: e.to, ...(e.notes ? { notes: e.notes } : {}), count: at.length, lines: [...new Set(at)].slice(0, 12) });
+  }
+  return hits;
+}
+
+/** Source-engine API patterns that should not survive in the ported file. */
+export function leftovers(text, from, to) {
+  const map = mapFor(from, to);
+  if (!map) return [];
+  const out = [];
+  for (const e of map.entries) {
+    if (!e.leftoverRe) continue;
+    e.leftoverRe.lastIndex = 0;
+    const n = (text.match(e.leftoverRe) ?? []).length;
+    if (n) out.push({ id: e.id, pattern: e.leftover, count: n, use: e.to });
+  }
+  return out;
+}
+
+/** Lifecycle names that legitimately change across engines (for symbol-parity checks). */
+export const LIFECYCLE_EQUIV = [
+  ['_ready', '_enter_tree', 'Awake', 'Start', 'BeginPlay', 'OnEnable', 'constructor', 'init', '_Ready', '_EnterTree'],
+  ['_process', 'Update', 'Tick', 'LateUpdate', 'update', '_Process'],
+  ['_physics_process', 'FixedUpdate', 'Tick', 'fixedUpdate', '_PhysicsProcess', 'physicsUpdate'],
+  ['_input', '_unhandled_input', 'OnInput', 'SetupPlayerInputComponent', 'onKeyDown', '_Input', '_UnhandledInput'],
+  ['_exit_tree', 'OnDestroy', 'OnDisable', 'EndPlay', 'dispose', 'destroy', '_ExitTree'],
+  ['OnTriggerEnter', 'body_entered', '_on_body_entered', 'OnOverlapBegin', 'NotifyActorBeginOverlap', 'onTriggerEnter'],
+];