reverseport 0.0.0-stage → 1.2.0

package/port/hooks/guard.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+// Claude Code hooks for the ReversePort plugin: a deterministic guard around ReversePort's tools.
+// Adapted from rea-jev's hook layer (MIT, Juan Alvarado): the same four points (session start, before a tool, after a
+// tool, before "done"), with rules in code only. No model or network is called: ReversePort stays local.
+//
+//   session  short note on how to keep findings honest (proof cases, optional Stashpad memory)
+//   pre      deny a non-loopback CDP/Inspector endpoint; ask before a tool runs, attaches to or controls a program;
+//            ask when an argument carries what looks like a password, token or key
+//   post     append a small event (tool, input hash, ok/error, caseId) to the session log in the workspace
+//   stop     once per stop: block "done" while a proof case touched in this session fails its check
+//
+// REVERSEPORT_HOOKS=off turns them off, =shadow only logs what they would do. Every error fails open (exit 0, silent).
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { isMainModule } from '../src/main-module.mjs';
+
+const MODE = String(process.env.REVERSEPORT_HOOKS ?? 'on').toLowerCase();
+const TOOL = /^mcp__(?:plugin_reverseport_)?reverseport__(.+)$/;
+const RUNTIME_PREFIX = ['capture_', 'observe_'];
+const RUNTIME_EXACT = new Set([
+  'start_frida_session', 'instrument_with_frida', 'load_frida_script', 'resume_frida_session',
+  'start_gdb_session', 'gdb_console', 'start_rizin_debug_session', 'rizin_debug_command', 'execute_rizin_command', 'cutter_command',
+  'install_adb_package', 'uninstall_adb_package', 'push_adb_file', 'start_adb_app', 'start_adb_activity', 'stop_adb_app',
+]);
+const ENDPOINT_KEYS = new Set(['cdp_endpoint', 'inspector_endpoint']);
+const SECRET_KEY = /(^|[_-])(pass(word|wd|phrase)?|secret|token|api[_-]?key|private[_-]?key|auth|credential)s?$/i;
+const SECRET_VALUE = [/-----BEGIN [A-Z ]*PRIVATE KEY-----/, /\bAKIA[0-9A-Z]{16}\b/, /\bgh[pousr]_[A-Za-z0-9]{36,}\b/, /\bsk-[A-Za-z0-9_-]{20,}\b/, /\bxox[abpr]-[A-Za-z0-9-]{10,}\b/];
+
+const silent = () => process.exit(0);
+const emit = obj => { process.stdout.write(JSON.stringify(obj)); process.exit(0); };
+
+export const bare = name => TOOL.exec(String(name ?? ''))?.[1] ?? null;
+export const isRuntime = name => RUNTIME_EXACT.has(name) || RUNTIME_PREFIX.some(p => name.startsWith(p));
+
+function isLoopback(value) {
+  try {
+    const host = new URL(/^[a-z]+:\/\//i.test(value) ? value : `ws://${value}`).hostname.replace(/^\[|\]$/g, '');
+    return host === 'localhost' || host === '::1' || /^127\./.test(host);
+  } catch { return false; }
+}
+
+/** Walk the input once; report endpoint and secret findings with their key paths. */
+export function findings(input) {
+  const out = { endpoints: [], secrets: [] };
+  const visit = (v, at, key) => {
+    if (typeof v === 'string') {
+      if (ENDPOINT_KEYS.has(key) && v.trim() && !isLoopback(v.trim())) out.endpoints.push(at);
+      if ((SECRET_KEY.test(key ?? '') && v.trim().length >= 6) || SECRET_VALUE.some(r => r.test(v))) out.secrets.push(at);
+    } else if (Array.isArray(v)) v.forEach((x, i) => visit(x, `${at}[${i}]`, key));
+    else if (v && typeof v === 'object') for (const [k, x] of Object.entries(v)) visit(x, at ? `${at}.${k}` : k, k);
+  };
+  visit(input ?? {}, '', null);
+  return out;
+}
+
+/** The PreToolUse decision, or null to stay out of the way. */
+export function decide(name, input) {
+  const f = findings(input);
+  if (f.endpoints.length) return { decision: 'deny', reason: `ReversePort guard: ${f.endpoints.join(', ')} points to another machine. Attach only to a browser or process on this computer (localhost / 127.0.0.1).` };
+  if (f.secrets.length) return { decision: 'ask', reason: `ReversePort guard: ${f.secrets.join(', ')} looks like a password, token or key. Check with the user before it is used or saved.` };
+  if (isRuntime(name)) return { decision: 'ask', reason: `ReversePort guard: ${name} runs, attaches to or controls a program instead of only reading it. Confirm the user wants that, on a target they own or may examine.` };
+  return null;
+}
+
+function workspace() { return path.resolve(process.env.REVERSEPORT_HOME?.trim() || path.join(process.env.HOME || process.env.USERPROFILE || '.', '.reverseport')); }
+const logFile = sid => path.join(workspace(), 'sessions', `${String(sid ?? 'unknown').replace(/[^A-Za-z0-9_-]/g, '_').slice(0, 80)}.jsonl`);
+const hashOf = v => crypto.createHash('sha256').update(JSON.stringify(v ?? {})).digest('hex').slice(0, 16);
+
+function append(sid, event) {
+  const file = logFile(sid);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.appendFileSync(file, `${JSON.stringify({ at: new Date().toISOString(), ...event })}\n`);
+}
+
+function events(sid) {
+  try { return fs.readFileSync(logFile(sid), 'utf8').split('\n').filter(Boolean).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean); } catch { return []; }
+}
+
+function responseText(r) {
+  if (typeof r === 'string') return r;
+  const parts = Array.isArray(r) ? r : Array.isArray(r?.content) ? r.content : [];
+  return parts.map(p => (typeof p === 'string' ? p : p?.text ?? '')).join('\n');
+}
+
+async function readInput() {
+  let raw = '';
+  for await (const chunk of process.stdin) raw += chunk;
+  try { return JSON.parse(raw); } catch { return null; }
+}
+
+async function main() {
+  const phase = process.argv[2];
+  if (MODE === 'off') return silent();
+  const input = await readInput();
+  if (!input) return silent();
+
+  if (phase === 'session') {
+    return emit({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: 'ReversePort: for an investigation or port, keep a proof case (re_case: evidence → claims that cite it → decision → tests). Say "unknown" rather than guess. If Stashpad is installed, re_case init recalls earlier findings and remember proposes new ones for the user to review.' } });
+  }
+
+  const name = bare(input.tool_name);
+  if (phase === 'pre') {
+    if (!name) return silent();
+    const verdict = decide(name, input.tool_input);
+    if (!verdict) return silent();
+    try { append(input.session_id, { kind: 'pre', tool: name, decision: verdict.decision, shadow: MODE === 'shadow' || undefined }); } catch { /* the log is a bonus */ }
+    if (MODE === 'shadow') return silent();
+    return emit({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: verdict.decision, permissionDecisionReason: verdict.reason } });
+  }
+
+  if (phase === 'post') {
+    if (!name) return silent();
+    const text = responseText(input.tool_response);
+    const ok = !/"error"\s*:\s*\{/.test(text.slice(0, 400)) && input.tool_response?.isError !== true;
+    const caseId = name === 're_case' ? (input.tool_input?.caseId ?? /"caseId"\s*:\s*"([a-z0-9-]+)"/.exec(text)?.[1]) : undefined;
+    append(input.session_id, { kind: 'post', tool: name, input: hashOf(input.tool_input), ok, ...(caseId ? { caseId } : {}) });
+    return silent();
+  }
+
+  if (phase === 'stop') {
+    if (input.stop_hook_active) return silent();
+    const cases = [...new Set(events(input.session_id).filter(e => e.caseId).map(e => e.caseId))];
+    if (!cases.length) return silent();
+    const { caseTool } = await import('../src/proofcase.mjs');
+    const failing = [];
+    for (const caseId of cases) {
+      try { const r = await caseTool({ action: 'check', caseId }); if (!r.passed) failing.push(`${caseId}: ${r.errors.slice(0, 3).join('; ')}`); } catch { /* a case that cannot be read is not this hook's call */ }
+    }
+    if (!failing.length) return silent();
+    if (MODE === 'shadow') { append(input.session_id, { kind: 'stop', decision: 'block', shadow: true }); return silent(); }
+    return emit({ decision: 'block', reason: `ReversePort guard: a proof case from this session does not pass its check — ${failing.join(' | ')}. Fix it (re_case {action:"check"} lists every finding), or tell the user plainly what is unproven and why.` });
+  }
+  return silent();
+}
+
+if (isMainModule(import.meta.url)) {
+  const timer = setTimeout(silent, 9000); timer.unref?.();
+  main().catch(() => silent());
+}

package/port/knowledge/engines.json

@@ -0,0 +1,67 @@
+{
+  "godot": {
+    "name": "Godot 4 (GDScript)",
+    "language": "gdscript",
+    "scriptExt": ".gd",
+    "sceneFormat": ".tscn (text) / .scn (binary)",
+    "axes": { "right": "+X", "up": "+Y", "forward": "-Z (cameras, look_at, Vector3.FORWARD)", "modelFront": "+Z (Vector3.MODEL_FRONT, glTF imports)" },
+    "handedness": "right",
+    "units": "meters",
+    "eulerOrder": "YXZ (rotation in radians, rotation_degrees in degrees)",
+    "fov": "Camera3D.fov is vertical (keep_aspect = KEEP_HEIGHT, default)",
+    "physicsTick": "60 Hz (physics/common/physics_ticks_per_second)",
+    "lifecycle": ["_init", "_enter_tree", "_ready", "_process(delta)", "_physics_process(delta)", "_input(event)", "_unhandled_input(event)", "_exit_tree", "_notification(what)"]
+  },
+  "godot-csharp": {
+    "name": "Godot 4 (C#)",
+    "language": "csharp",
+    "scriptExt": ".cs",
+    "sceneFormat": ".tscn",
+    "axes": { "right": "+X", "up": "+Y", "forward": "-Z", "modelFront": "+Z" },
+    "handedness": "right",
+    "units": "meters",
+    "eulerOrder": "YXZ",
+    "fov": "vertical",
+    "physicsTick": "60 Hz",
+    "lifecycle": ["_Ready()", "_Process(double delta)", "_PhysicsProcess(double delta)", "_Input(InputEvent @event)", "_UnhandledInput(InputEvent @event)", "_ExitTree()"]
+  },
+  "unity": {
+    "name": "Unity (C#)",
+    "language": "csharp",
+    "scriptExt": ".cs",
+    "sceneFormat": ".unity / .prefab (YAML when Asset Serialization = Force Text)",
+    "axes": { "right": "+X", "up": "+Y", "forward": "+Z (transform.forward)" },
+    "handedness": "left",
+    "units": "meters",
+    "eulerOrder": "applied Z, then X, then Y (same matrix order as Godot YXZ); degrees",
+    "fov": "Camera.fieldOfView is vertical (degrees)",
+    "physicsTick": "50 Hz (Fixed Timestep 0.02 s)",
+    "lifecycle": ["Awake()", "OnEnable()", "Start()", "FixedUpdate()", "Update()", "LateUpdate()", "OnDisable()", "OnDestroy()"]
+  },
+  "unreal": {
+    "name": "Unreal Engine 5 (C++ / Blueprint)",
+    "language": "cpp",
+    "scriptExt": ".h + .cpp",
+    "sceneFormat": ".umap (level) / .uasset (Blueprint) — binary",
+    "axes": { "right": "+Y", "up": "+Z", "forward": "+X" },
+    "handedness": "left",
+    "units": "centimeters",
+    "eulerOrder": "FRotator(Pitch, Yaw, Roll) in degrees",
+    "fov": "UCameraComponent::FieldOfView is horizontal (degrees)",
+    "physicsTick": "variable by default (frame rate); optional substepping / async physics tick",
+    "lifecycle": ["constructor (CreateDefaultSubobject)", "PostInitializeComponents()", "BeginPlay()", "Tick(float DeltaTime)", "EndPlay(EEndPlayReason::Type)"]
+  },
+  "threejs": {
+    "name": "three.js (TypeScript)",
+    "language": "typescript",
+    "scriptExt": ".ts",
+    "sceneFormat": "code + glTF (.glb) assets",
+    "axes": { "right": "+X", "up": "+Y", "forward": "-Z (cameras and lights look down -Z; Object3D.lookAt points +Z for other objects)" },
+    "handedness": "right",
+    "units": "meters by convention (physical lights assume meters)",
+    "eulerOrder": "XYZ by default (radians); set object.rotation.order = 'YXZ' to match Godot",
+    "fov": "PerspectiveCamera.fov is vertical (degrees)",
+    "physicsTick": "none built in — fixed-step accumulator with Rapier / cannon-es",
+    "lifecycle": ["constructor / init()", "renderer.setAnimationLoop(update)", "dispose()"]
+  }
+}

package/port/knowledge/footprints.json

@@ -0,0 +1,189 @@
+{
+  "about": "What an engine or stack leaves behind in a shipped game or app: install layout, file formats, scripting, which ReversePort tools read it, and the natural rebuild target. Used by re_lookup (to tell an agent where the material is and how it is structured, without files) and re_blueprint. Only layouts that are stable across versions are listed.",
+  "footprints": {
+    "unity": {
+      "name": "Unity",
+      "match": ["unity"],
+      "engineId": "unity",
+      "scripting": "C# (Mono or IL2CPP)",
+      "layout": [
+        "<Game>.exe + UnityPlayer.dll (Windows player)",
+        "<Game>_Data/ — globalgamemanagers (holds the Unity version), level0…levelN (scenes), sharedassets*.assets, resources.assets",
+        "<Game>_Data/Managed/Assembly-CSharp.dll — game code (Mono builds)",
+        "GameAssembly.dll + <Game>_Data/il2cpp_data/Metadata/global-metadata.dat — game code compiled to native (IL2CPP builds)",
+        "<Game>_Data/StreamingAssets/ — files shipped as-is (often AssetBundles, videos, configs)"
+      ],
+      "formats": [".assets", ".resS", "AssetBundles (UnityFS)", ".dll (.NET)"],
+      "readWith": ["re_scan on the install folder → engine, version, Mono or IL2CPP", "re_binary on Assembly-CSharp.dll → classes and methods (Mono)", "re_probe on .assets/.resS for embedded data"],
+      "limits": "IL2CPP builds have no .NET assemblies: only native code plus metadata. Asset files are binary serialized; ReversePort lists and probes them but does not unpack them.",
+      "rebuildTarget": "unity"
+    },
+    "godot": {
+      "name": "Godot",
+      "match": ["godot"],
+      "engineId": "godot",
+      "scripting": "GDScript or C#",
+      "layout": [
+        "<Game>.exe / .x86_64 + <Game>.pck (or the pack embedded at the end of the executable)",
+        "inside the pack: project.godot, *.tscn/*.scn scenes, *.gd scripts (text or tokenized), .import/ converted assets",
+        "C# games: data_<Game>_<platform>/ with the .NET assemblies"
+      ],
+      "formats": [".pck (GDPC)", ".tscn/.scn", ".gd/.gdc", ".ctex/.stex", ".import"],
+      "readWith": ["re_scan → engine + packs", "re_archive on the .pck or .exe → list/extract scenes and scripts", "re_scene on extracted .tscn"],
+      "limits": "Encrypted packs are reported and left alone.",
+      "rebuildTarget": "godot"
+    },
+    "unreal": {
+      "name": "Unreal Engine",
+      "match": ["unreal"],
+      "engineId": "unreal",
+      "scripting": "C++ and Blueprints",
+      "layout": [
+        "<Project>/Binaries/<Platform>/<Project>-<Platform>-Shipping.exe — game code (native)",
+        "<Project>/Content/Paks/*.pak — cooked assets (UE5 also .utoc/.ucas IoStore containers)",
+        "Engine/ — engine binaries and shared content"
+      ],
+      "formats": [".pak", ".utoc/.ucas", ".uasset/.umap (cooked)", ".exe (native)"],
+      "readWith": ["re_scan → Unreal build, paks, IoStore", "re_archive identifies paks (header only)", "re_binary on the Shipping exe → imports, sections, strings"],
+      "limits": "Paks are often encrypted and cooked assets are binary; no source code ships. Rebuild from observation.",
+      "rebuildTarget": "unreal"
+    },
+    "gamemaker": {
+      "name": "GameMaker",
+      "match": ["gamemaker", "game maker"],
+      "scripting": "GML",
+      "layout": ["<Game>.exe + data.win (all rooms, sprites, sounds and compiled code in one file); YYC builds compile GML to native code"],
+      "formats": ["data.win (FORM/IFF chunks)", "audiogroup*.dat"],
+      "readWith": ["re_scan → GameMaker build", "re_probe on data.win → chunk layout, embedded PNG/OGG"],
+      "limits": "YYC builds contain native code only.",
+      "rebuildTarget": "godot"
+    },
+    "rpgmaker": {
+      "name": "RPG Maker MV/MZ",
+      "match": ["rpg maker"],
+      "scripting": "JavaScript",
+      "layout": ["www/ or root: index.html, js/rpg_*.js (MV) or js/rmmz_*.js (MZ), js/plugins/*.js, data/*.json (maps, actors, items, events), img/, audio/"],
+      "formats": [".json", ".js", ".rpgmvp/.png_ (encrypted images, optional)", ".rpgmvo/.ogg_ (encrypted audio, optional)"],
+      "readWith": ["re_scan → RPG Maker MV/MZ", "re_symbols on js/plugins", "data/*.json is readable as is"],
+      "limits": "Encrypted images/audio are left alone.",
+      "rebuildTarget": "godot"
+    },
+    "renpy": {
+      "name": "Ren'Py",
+      "match": ["ren'py", "renpy"],
+      "scripting": "Ren'Py script / Python",
+      "layout": ["game/ with *.rpy (source), *.rpyc (compiled), *.rpa (archives with images/audio)", "renpy/ engine, lib/ Python runtime"],
+      "formats": [".rpy", ".rpyc", ".rpa"],
+      "readWith": ["re_scan → Ren'Py", "re_symbols on .rpy (labels, screens)"],
+      "rebuildTarget": "renpy"
+    },
+    "love2d": {
+      "name": "LÖVE",
+      "match": ["löve", "love2d", "love 2d"],
+      "scripting": "Lua",
+      "layout": ["<Game>.exe with a .love (zip) appended, or a .love file next to love.exe; main.lua + conf.lua inside"],
+      "formats": [".love (zip)", ".lua"],
+      "readWith": ["re_probe on the exe → embedded ZIP offset", "re_extract the ZIP, then re_archive"],
+      "rebuildTarget": "godot"
+    },
+    "source": {
+      "name": "Source engine (Valve)",
+      "match": ["source engine", "source 2", "source"],
+      "scripting": "C++ (Source 2: also Lua/Panorama JS)",
+      "layout": ["<game>/ with gameinfo.txt, bin/ (client.dll, server.dll), *.vpk archives, maps/*.bsp (Source 2: .vpk with .vmap_c)"],
+      "formats": [".vpk", ".bsp", ".mdl/.vtx/.vvd", ".vtf/.vmt"],
+      "readWith": ["re_binary on client.dll/server.dll", "re_probe on .vpk/.bsp"],
+      "rebuildTarget": "unreal"
+    },
+    "electron": {
+      "name": "Electron",
+      "match": ["electron"],
+      "scripting": "JavaScript/TypeScript + HTML/CSS",
+      "layout": ["<App>.exe + resources/app.asar (the app's JS/HTML/CSS) or resources/app/ unpacked; *.node native modules"],
+      "formats": [".asar", ".js", ".node"],
+      "readWith": ["re_scan → Electron build", "re_archive on app.asar → list/extract", "re_graph/re_symbols on the extracted code"],
+      "rebuildTarget": "electron"
+    },
+    "nwjs": {
+      "name": "NW.js",
+      "match": ["nw.js", "node-webkit", "nwjs"],
+      "scripting": "JavaScript",
+      "layout": ["nw.exe/<Game>.exe + package.nw (zip) or package.json + html/js next to it (Construct 2/3 and RPG Maker MV desktop exports use it)"],
+      "formats": [".nw (zip)", ".js"],
+      "readWith": ["re_archive on package.nw", "re_probe on the exe for an appended zip"],
+      "rebuildTarget": "threejs"
+    },
+    "monogame": {
+      "name": "MonoGame / XNA / FNA",
+      "match": ["monogame", "xna", "fna"],
+      "scripting": "C#",
+      "layout": ["<Game>.exe/.dll (.NET) + Content/*.xnb (compiled content)"],
+      "formats": [".xnb", ".dll (.NET)"],
+      "readWith": ["re_binary on the game .exe/.dll → .NET types and methods", "re_probe on .xnb"],
+      "rebuildTarget": "godot-csharp"
+    },
+    "construct": {
+      "name": "Construct",
+      "match": ["construct"],
+      "scripting": "event sheets (exported to JavaScript)",
+      "layout": ["HTML5 export: index.html, scripts/c3runtime.js (Construct 3) or c2runtime.js, data.json (project data), images/, media/"],
+      "formats": ["data.json", "c3runtime.js"],
+      "readWith": ["re_scan on the export folder", "data.json is readable as is"],
+      "rebuildTarget": "godot"
+    },
+    "defold": {
+      "name": "Defold",
+      "match": ["defold"],
+      "scripting": "Lua",
+      "layout": ["game.arcd + game.arci (resource archive and index), game.dmanifest, game.projectc"],
+      "formats": [".arcd/.arci", ".projectc"],
+      "readWith": ["re_probe on game.arcd"],
+      "rebuildTarget": "godot"
+    },
+    "cocos": {
+      "name": "Cocos2d-x / Cocos Creator",
+      "match": ["cocos"],
+      "scripting": "C++, Lua or JavaScript/TypeScript",
+      "layout": ["Android: lib/<abi>/libcocos2d*.so or libcocos*.so, assets/ with .jsc/.luac or res/ and src/"],
+      "formats": [".jsc/.luac (compiled scripts)", ".plist sprite sheets"],
+      "readWith": ["re_archive on the .apk", "re_binary on the .so"],
+      "rebuildTarget": "godot"
+    },
+    "libgdx": {
+      "name": "libGDX / Java",
+      "match": ["libgdx", "java"],
+      "scripting": "Java/Kotlin",
+      "layout": ["desktop: <game>.jar (classes + assets); Android: classes*.dex + assets/"],
+      "formats": [".jar", ".class", ".dex"],
+      "readWith": ["re_archive on the .jar/.apk", "re_binary on .class/.dex → classes and methods"],
+      "rebuildTarget": "godot"
+    },
+    "flutter": {
+      "name": "Flutter",
+      "match": ["flutter"],
+      "scripting": "Dart",
+      "layout": ["Android: lib/<abi>/libapp.so (compiled Dart) + libflutter.so, assets/flutter_assets/ (images, fonts, AssetManifest)", "iOS: Frameworks/App.framework + flutter_assets"],
+      "formats": ["libapp.so (AOT snapshot)", "flutter_assets/"],
+      "readWith": ["re_archive on the .apk", "re_binary on libapp.so → strings"],
+      "rebuildTarget": "flutter"
+    },
+    "react-native": {
+      "name": "React Native",
+      "match": ["react native", "react-native"],
+      "scripting": "JavaScript/TypeScript",
+      "layout": ["Android: assets/index.android.bundle (JS or Hermes bytecode); iOS: main.jsbundle"],
+      "formats": ["index.android.bundle", "Hermes bytecode (.hbc)"],
+      "readWith": ["re_archive on the .apk", "re_probe on the bundle"],
+      "rebuildTarget": "react-native"
+    },
+    "web": {
+      "name": "Web app / browser game",
+      "match": ["html5", "javascript", "webgl", "three.js", "phaser", "pixijs", "babylon.js", "playcanvas"],
+      "scripting": "JavaScript/TypeScript (+ WebAssembly)",
+      "layout": ["index.html + bundled scripts (often hashed names under /assets or /_next), styles, images, .wasm and data files loaded at runtime"],
+      "formats": [".js", ".wasm", ".data", ".json", ".glb"],
+      "readWith": ["re_lookup {url} lists the scripts, wasm and data files the page loads", "re_binary on a downloaded .wasm"],
+      "rebuildTarget": "threejs"
+    }
+  }
+}

package/port/knowledge/maps/godot-godot-csharp.json

@@ -0,0 +1,38 @@
+{
+  "from": "godot",
+  "to": "godot-csharp",
+  "title": "Godot 4 GDScript → Godot 4 C# (.NET)",
+  "conventions": [
+    "Needs the .NET build of Godot; the project gets a .csproj. Each script: public partial class Name : BaseType, file name = class name.",
+    "Scenes stay as they are: swap the script path in each .tscn ext_resource from res://x.gd to res://X.cs once the C# class compiles.",
+    "Names become PascalCase: _physics_process → _PhysicsProcess, move_and_slide → MoveAndSlide, global_position → GlobalPosition. Delta is double.",
+    "Struct properties cannot be changed in place: var v = Velocity; v.X = 3; Velocity = v;",
+    "Engine collections are Godot.Collections.Array/Dictionary (Variant-compatible); use them for exported and signal data, .NET List/Dictionary elsewhere."
+  ],
+  "entries": [
+    { "id": "script-class", "topic": "structure", "from": "class_name Player / extends CharacterBody3D", "to": "public partial class Player : CharacterBody3D", "pattern": "^extends\\s" },
+    { "id": "ready", "topic": "lifecycle", "from": "_ready()", "to": "public override void _Ready()", "pattern": "\\bfunc\\s+_ready\\b" },
+    { "id": "process", "topic": "lifecycle", "from": "_process(delta)", "to": "public override void _Process(double delta)", "pattern": "\\bfunc\\s+_process\\b" },
+    { "id": "physics-process", "topic": "lifecycle", "from": "_physics_process(delta)", "to": "public override void _PhysicsProcess(double delta)", "pattern": "\\bfunc\\s+_physics_process\\b" },
+    { "id": "input-event", "topic": "input", "from": "_input(event) / _unhandled_input(event)", "to": "public override void _Input(InputEvent @event) / _UnhandledInput", "pattern": "\\bfunc\\s+_(unhandled_)?input\\b" },
+    { "id": "export", "topic": "inspector", "from": "@export var speed := 6.0", "to": "[Export] public float Speed { get; set; } = 6f;", "pattern": "@export" },
+    { "id": "onready", "topic": "scene tree", "from": "@onready var anim = $AnimationPlayer", "to": "private AnimationPlayer _anim; … in _Ready(): _anim = GetNode<AnimationPlayer>(\"AnimationPlayer\");", "pattern": "@onready" },
+    { "id": "get-node", "topic": "scene tree", "from": "$Path / get_node(\"Path\") / %Unique", "to": "GetNode<T>(\"Path\") / GetNode<T>(\"%Unique\")", "pattern": "(get_node\\(|\\$[A-Za-z\"%])", "leftover": "\\bget_node\\(|\\$\\w" },
+    { "id": "signal-declare", "topic": "events", "from": "signal hit(damage: int)", "to": "[Signal] public delegate void HitEventHandler(int damage);", "pattern": "^signal\\s" },
+    { "id": "signal-emit", "topic": "events", "from": "hit.emit(d) / emit_signal(\"hit\", d)", "to": "EmitSignal(SignalName.Hit, d);", "pattern": "\\.emit\\(|emit_signal\\(", "leftover": "emit_signal\\(" },
+    { "id": "signal-connect", "topic": "events", "from": "hit.connect(_on_hit)", "to": "Hit += OnHit;", "pattern": "\\.connect\\(" },
+    { "id": "preload", "topic": "resources", "from": "preload(\"res://x.tscn\")", "to": "GD.Load<PackedScene>(\"res://x.tscn\") (cache it in a static readonly field)", "pattern": "\\bpreload\\(", "leftover": "\\bpreload\\(" },
+    { "id": "instantiate", "topic": "scene tree", "from": "scene.instantiate()", "to": "scene.Instantiate<Node3D>()", "pattern": "\\.instantiate\\(" },
+    { "id": "queue-free", "topic": "scene tree", "from": "queue_free()", "to": "QueueFree()", "pattern": "\\bqueue_free\\(?", "leftover": "\\bqueue_free\\(" },
+    { "id": "timer-await", "topic": "async", "from": "await get_tree().create_timer(t).timeout", "to": "await ToSignal(GetTree().CreateTimer(t), SceneTreeTimer.SignalName.Timeout);", "pattern": "create_timer\\(" },
+    { "id": "await-signal", "topic": "async", "from": "await some_signal", "to": "await ToSignal(obj, Obj.SignalName.SomeSignal); (method becomes async)", "pattern": "\\bawait\\s" },
+    { "id": "input", "topic": "input", "from": "Input.is_action_pressed / get_axis", "to": "Input.IsActionPressed / Input.GetAxis", "pattern": "Input\\.(is_action|get_axis|get_vector)" },
+    { "id": "velocity", "topic": "physics", "from": "velocity.x = …; move_and_slide()", "to": "var v = Velocity; v.X = …; Velocity = v; MoveAndSlide();", "pattern": "\\bvelocity\\.|move_and_slide\\(" },
+    { "id": "groups", "topic": "architecture", "from": "add_to_group(\"x\")", "to": "AddToGroup(\"x\")", "pattern": "add_to_group\\(" },
+    { "id": "autoload", "topic": "architecture", "from": "Global.add_score(…) (autoload by name)", "to": "GetNode<Global>(\"/root/Global\").AddScore(…) or a static Instance set in _Ready", "pattern": "^\\[autoload\\]" },
+    { "id": "print", "topic": "debug", "from": "print(), push_error()", "to": "GD.Print(), GD.PushError()", "pattern": "\\b(print|push_error|push_warning)\\(", "leftover": "^\\s*print\\(" },
+    { "id": "math", "topic": "math", "from": "lerp, clamp, deg_to_rad, randf", "to": "Mathf.Lerp, Mathf.Clamp, Mathf.DegToRad, GD.Randf()", "pattern": "\\b(lerp|clamp|deg_to_rad|randf|randi)\\(" },
+    { "id": "typed", "topic": "language", "from": "var x := 1, Array[int], Dictionary", "to": "var x = 1; Godot.Collections.Array<int>; Godot.Collections.Dictionary", "pattern": "\\bArray\\[|\\bDictionary\\b" },
+    { "id": "match", "topic": "language", "from": "match value:", "to": "switch statement / switch expression", "pattern": "^\\s*match\\s" }
+  ]
+}

package/port/knowledge/maps/godot-threejs.json

@@ -0,0 +1,42 @@
+{
+  "from": "godot",
+  "to": "threejs",
+  "title": "Godot 4 (GDScript) → three.js (TypeScript, browser)",
+  "conventions": [
+    "three.js is a renderer, not a game engine: physics, input mapping, scene files, audio buses and UI are yours to choose. A common stack: three + Rapier (@dimforge/rapier3d-compat) for physics, plain DOM/CSS for UI, Vite for building.",
+    "Axes match Godot (right-handed, Y up, cameras look down -Z, meters): positions and quaternions carry over unchanged. Godot's default Euler order is YXZ; set object.rotation.order = 'YXZ' when copying Euler angles.",
+    "Godot scenes: export meshes and materials as glTF 2.0 (Scene → Export As → glTF 2.0) and load them with GLTFLoader; recreate the node logic in TypeScript classes that own an Object3D. ReversePort can write a TypeScript scene-builder module from a .tscn (port_scene).",
+    "Each GDScript becomes a TypeScript class with update(dt) and fixedUpdate(dt) methods; a small game loop calls them from renderer.setAnimationLoop.",
+    "Dispose geometries, materials and textures when removing objects (the browser does not free GPU memory for you)."
+  ],
+  "entries": [
+    { "id": "script-class", "topic": "structure", "from": "extends Node3D", "to": "class X { object = new THREE.Group(); update(dt: number) {} }", "pattern": "^extends\\s" },
+    { "id": "ready", "topic": "lifecycle", "from": "_ready()", "to": "constructor / async init() after assets are loaded", "pattern": "\\bfunc\\s+_ready\\b" },
+    { "id": "process", "topic": "lifecycle", "from": "_process(delta)", "to": "update(dt) called from renderer.setAnimationLoop with clock.getDelta()", "pattern": "\\bfunc\\s+_process\\b" },
+    { "id": "physics-process", "topic": "lifecycle", "from": "_physics_process(delta)", "to": "fixedUpdate(1/60) from an accumulator loop; step the physics world there", "pattern": "\\bfunc\\s+_physics_process\\b" },
+    { "id": "input", "topic": "input", "from": "Input.is_action_pressed(\"x\") / InputMap", "to": "own action map over keydown/keyup listeners and the Gamepad API (navigator.getGamepads())", "pattern": "Input\\.(is_action|get_axis|get_vector)" },
+    { "id": "signal", "topic": "events", "from": "signal / emit / connect", "to": "THREE.EventDispatcher (dispatchEvent / addEventListener) or a typed emitter", "pattern": "^signal\\s|\\.emit\\(|\\.connect\\(" },
+    { "id": "get-node", "topic": "scene tree", "from": "$Path / get_node", "to": "object.getObjectByName(\"Path\") or keep direct references in the class", "pattern": "(get_node\\(|\\$[A-Za-z\"%])", "leftover": "\\bget_node\\(" },
+    { "id": "preload", "topic": "resources", "from": "preload(\"res://x.tscn\")", "to": "await new GLTFLoader().loadAsync('x.glb') once, then clone per instance", "pattern": "\\bpreload\\(|\\bload\\(" },
+    { "id": "instantiate", "topic": "scene tree", "from": "instantiate() + add_child()", "to": "template.clone() (SkeletonUtils.clone for skinned meshes) + parent.add(obj)", "pattern": "\\.instantiate\\(" },
+    { "id": "queue-free", "topic": "scene tree", "from": "queue_free()", "to": "obj.removeFromParent() + dispose() of geometry/material/texture", "pattern": "\\bqueue_free\\(?", "leftover": "queue_free" },
+    { "id": "timer", "topic": "async", "from": "await get_tree().create_timer(t).timeout", "to": "await new Promise(r => setTimeout(r, t * 1000)) — or a game-time timer that respects pause", "pattern": "create_timer\\(" },
+    { "id": "tween", "topic": "animation", "from": "create_tween()", "to": "a small tween in update(dt), or @tweenjs/tween.js / GSAP", "pattern": "create_tween\\(" },
+    { "id": "character-body", "topic": "physics", "from": "CharacterBody3D.move_and_slide()", "to": "Rapier KinematicCharacterController.computeColliderMovement + setNextKinematicTranslation", "pattern": "move_and_slide\\(|CharacterBody3D" },
+    { "id": "rigid-body", "topic": "physics", "from": "RigidBody3D.apply_central_impulse", "to": "Rapier RigidBody.applyImpulse({x, y, z}, true)", "pattern": "RigidBody3D|apply_(central_)?impulse\\(" },
+    { "id": "area", "topic": "physics", "from": "Area3D.body_entered", "to": "Rapier sensor collider + collision events (EventQueue)", "pattern": "Area3D|body_entered" },
+    { "id": "raycast", "topic": "physics", "from": "RayCast3D", "to": "THREE.Raycaster (meshes) or Rapier world.castRay (physics)", "pattern": "RayCast3D|intersect_ray" },
+    { "id": "camera", "topic": "rendering", "from": "Camera3D (fov vertical)", "to": "THREE.PerspectiveCamera(fov, aspect, near, far) (fov vertical, degrees)", "pattern": "Camera3D" },
+    { "id": "lights", "topic": "rendering", "from": "DirectionalLight3D / OmniLight3D / SpotLight3D", "to": "DirectionalLight (+ target) / PointLight / SpotLight", "pattern": "(Directional|Omni|Spot)Light3D", "notes": "three.js uses physical light units; retune intensities." },
+    { "id": "environment", "topic": "rendering", "from": "WorldEnvironment (sky, tonemap, glow)", "to": "scene.background / scene.environment (PMREMGenerator), renderer.toneMapping, postprocessing (EffectComposer, UnrealBloomPass)", "pattern": "WorldEnvironment|Environment" },
+    { "id": "animation", "topic": "animation", "from": "AnimationPlayer.play(\"x\")", "to": "new THREE.AnimationMixer(root).clipAction(clip).play(); mixer.update(dt)", "pattern": "AnimationPlayer" },
+    { "id": "audio", "topic": "audio", "from": "AudioStreamPlayer3D", "to": "THREE.PositionalAudio with an AudioListener on the camera", "pattern": "AudioStreamPlayer" },
+    { "id": "ui", "topic": "ui", "from": "Control / Label / CanvasLayer", "to": "HTML/CSS overlay (or a UI library) above the canvas", "pattern": "\\b(Control|Label|Button|CanvasLayer)\\b" },
+    { "id": "autoload", "topic": "architecture", "from": "Autoload singleton", "to": "an exported module-level instance (ES module singletons)", "pattern": "^\\[autoload\\]" },
+    { "id": "change-scene", "topic": "architecture", "from": "change_scene_to_file", "to": "dispose the current world, build the next one (your own scene manager)", "pattern": "change_scene_to_(file|packed)\\(" },
+    { "id": "groups", "topic": "architecture", "from": "groups", "to": "Sets/arrays per group, or object.userData.tags", "pattern": "(add_to_group|get_nodes_in_group)\\(" },
+    { "id": "print", "topic": "debug", "from": "print()", "to": "console.log()", "pattern": "\\bprint\\(", "leftover": "^\\s*print\\(" },
+    { "id": "math", "topic": "math", "from": "lerp, clamp, deg_to_rad", "to": "THREE.MathUtils.lerp, clamp, degToRad", "pattern": "\\b(lerp|clamp|deg_to_rad)\\(" },
+    { "id": "shader", "topic": "rendering", "from": ".gdshader", "to": "ShaderMaterial (GLSL) or TSL node materials (WebGPU renderer)", "pattern": "shader_type\\s" }
+  ]
+}

package/port/knowledge/maps/godot-unity.json

@@ -0,0 +1,62 @@
+{
+  "from": "godot",
+  "to": "unity",
+  "title": "Godot 4 (GDScript) → Unity (C#)",
+  "conventions": [
+    "One GDScript file becomes one C# MonoBehaviour (class name = file name in PascalCase; Unity requires the class name to match the file name).",
+    "A .tscn scene becomes a prefab; the main scene becomes a Unity scene. Child nodes become child GameObjects; a node's own type (CharacterBody3D, Area3D…) becomes components on that GameObject.",
+    "Coordinates: Godot is right-handed with -Z forward, Unity is left-handed with +Z forward. Mirror Z: position (x, y, -z), quaternion (-x, -y, z, w). Use port_convert; meshes imported separately keep their own importer orientation.",
+    "Godot angles are radians (rotation), Unity Euler angles are degrees (eulerAngles). Physics ticks: Godot 60 Hz, Unity 50 Hz by default (Time.fixedDeltaTime = 0.02).",
+    "Prefer serialized references ([SerializeField]) over path lookups; wire them in the prefab instead of get_node paths.",
+    "Unity has no per-node 'process' toggle like set_process; disable the component (enabled = false) or the GameObject."
+  ],
+  "entries": [
+    { "id": "script-class", "topic": "structure", "from": "extends Node3D / class_name X", "to": "public class X : MonoBehaviour", "pattern": "^extends\\s", "notes": "The Godot base type (CharacterBody3D, Area3D, RigidBody3D…) is not the C# base class: add the matching components (CharacterController, Collider+isTrigger, Rigidbody) to the GameObject." },
+    { "id": "ready", "topic": "lifecycle", "from": "_ready()", "to": "Awake() for self-setup, Start() when other objects must exist", "pattern": "\\bfunc\\s+_ready\\b", "notes": "Godot runs children's _ready before the parent's; Unity's Awake/Start order between objects is not guaranteed (use Script Execution Order if it matters)." },
+    { "id": "process", "topic": "lifecycle", "from": "_process(delta)", "to": "Update() with Time.deltaTime", "pattern": "\\bfunc\\s+_process\\b" },
+    { "id": "physics-process", "topic": "lifecycle", "from": "_physics_process(delta)", "to": "FixedUpdate() with Time.fixedDeltaTime", "pattern": "\\bfunc\\s+_physics_process\\b", "notes": "Default rates differ (60 vs 50 Hz); set Project Settings → Time → Fixed Timestep to 1/60 to keep tuning." },
+    { "id": "input-event", "topic": "input", "from": "_input(event) / _unhandled_input(event)", "to": "Input System actions (PlayerInput, InputAction.performed) or polling in Update()", "pattern": "\\bfunc\\s+_(unhandled_)?input\\b" },
+    { "id": "action-pressed", "topic": "input", "from": "Input.is_action_pressed(\"x\")", "to": "action.IsPressed() (Input System) / Input.GetButton(\"x\") (legacy)", "pattern": "Input\\.is_action_pressed\\(", "leftover": "Input\\.is_action" },
+    { "id": "action-just-pressed", "topic": "input", "from": "Input.is_action_just_pressed(\"x\")", "to": "action.WasPressedThisFrame() / Input.GetButtonDown(\"x\")", "pattern": "Input\\.is_action_just_(pressed|released)\\(" },
+    { "id": "get-axis", "topic": "input", "from": "Input.get_axis(\"neg\", \"pos\") / get_vector", "to": "action.ReadValue<float>() / ReadValue<Vector2>() or Input.GetAxis(\"Horizontal\")", "pattern": "Input\\.get_(axis|vector)\\(" },
+    { "id": "get-node", "topic": "scene tree", "from": "get_node(\"Path\") / $Path / %Unique", "to": "[SerializeField] reference wired in the prefab, or transform.Find(\"Path\") + GetComponent<T>()", "pattern": "(get_node\\(|\\$[A-Za-z\"%])", "leftover": "\\bget_node\\(|\\$\\w" },
+    { "id": "onready", "topic": "scene tree", "from": "@onready var x = $Y", "to": "assign in Awake(), or a serialized field", "pattern": "@onready" },
+    { "id": "export", "topic": "inspector", "from": "@export var speed := 6.0", "to": "[SerializeField] private float speed = 6f;", "pattern": "@export", "notes": "Range hints: @export_range(0, 10) → [Range(0, 10)]." },
+    { "id": "signal-declare", "topic": "events", "from": "signal hit(damage)", "to": "public event Action<int> Hit; (code) or public UnityEvent<int> onHit; (inspector wiring)", "pattern": "^signal\\s" },
+    { "id": "signal-emit", "topic": "events", "from": "hit.emit(d) / emit_signal(\"hit\", d)", "to": "Hit?.Invoke(d);", "pattern": "(\\.emit\\(|emit_signal\\()", "leftover": "emit_signal\\(" },
+    { "id": "signal-connect", "topic": "events", "from": "hit.connect(_on_hit) / [connection] in .tscn", "to": "Hit += OnHit; (and Hit -= OnHit in OnDestroy) or UnityEvent wiring in the inspector", "pattern": "\\.connect\\(", "notes": "Connections stored in .tscn files ([connection] sections) must be recreated: re_scene lists them." },
+    { "id": "preload", "topic": "resources", "from": "preload(\"res://x.tscn\")", "to": "[SerializeField] GameObject xPrefab; assigned in the inspector", "pattern": "\\bpreload\\(", "leftover": "\\bpreload\\(" },
+    { "id": "load", "topic": "resources", "from": "load(\"res://x\") at runtime", "to": "Resources.Load<T>(\"x\") (from a Resources folder) or Addressables.LoadAssetAsync<T>", "pattern": "\\b(load|ResourceLoader\\.load)\\(\"res://" },
+    { "id": "instantiate", "topic": "scene tree", "from": "scene.instantiate() + add_child(n)", "to": "Instantiate(prefab, parent) (or position/rotation overload)", "pattern": "\\.instantiate\\(" },
+    { "id": "queue-free", "topic": "scene tree", "from": "queue_free()", "to": "Destroy(gameObject)", "pattern": "\\bqueue_free\\(?", "leftover": "queue_free" },
+    { "id": "timer-await", "topic": "async", "from": "await get_tree().create_timer(t).timeout", "to": "coroutine: yield return new WaitForSeconds(t); (or await Awaitable.WaitForSecondsAsync(t) in Unity 2023.1+)", "pattern": "create_timer\\(" },
+    { "id": "await-signal", "topic": "async", "from": "await some_signal", "to": "coroutine with yield return new WaitUntil(...) or a TaskCompletionSource/Awaitable", "pattern": "\\bawait\\s" },
+    { "id": "tween", "topic": "animation", "from": "create_tween().tween_property(...)", "to": "coroutine with Mathf.Lerp over time, or a tween library (DOTween, PrimeTween)", "pattern": "create_tween\\(|\\bTween\\b", "notes": "Unity has no built-in tween engine." },
+    { "id": "character-body", "topic": "physics", "from": "CharacterBody3D + velocity + move_and_slide()", "to": "CharacterController.Move(velocity * Time.deltaTime) (handle gravity yourself), or a kinematic Rigidbody", "pattern": "\\bmove_and_slide\\(|CharacterBody3D", "notes": "move_and_slide uses the velocity property and delta internally; CharacterController.Move takes a displacement. is_on_floor() → controller.isGrounded." },
+    { "id": "rigid-body", "topic": "physics", "from": "RigidBody3D, apply_central_impulse(v), apply_central_force(v)", "to": "Rigidbody, AddForce(v, ForceMode.Impulse), AddForce(v)", "pattern": "RigidBody3D|apply_(central_)?(impulse|force)\\(" },
+    { "id": "area", "topic": "physics", "from": "Area3D + body_entered(body)", "to": "Collider with isTrigger = true + OnTriggerEnter(Collider other)", "pattern": "Area3D|body_entered|area_entered", "notes": "Unity needs a Rigidbody on at least one of the two objects for trigger messages." },
+    { "id": "raycast", "topic": "physics", "from": "RayCast3D node / PhysicsDirectSpaceState3D.intersect_ray", "to": "Physics.Raycast(origin, direction, out RaycastHit hit, maxDistance, layerMask)", "pattern": "RayCast3D|intersect_ray" },
+    { "id": "collision-layers", "topic": "physics", "from": "collision_layer / collision_mask (bit masks)", "to": "GameObject layers + the Layer Collision Matrix; LayerMask for queries", "pattern": "collision_(layer|mask)" },
+    { "id": "transform", "topic": "transform", "from": "position / global_position / global_transform.origin", "to": "transform.localPosition / transform.position", "pattern": "global_(position|transform)" },
+    { "id": "rotation", "topic": "transform", "from": "rotation (radians, Euler YXZ) / rotation_degrees / basis / quaternion", "to": "transform.localEulerAngles (degrees) / transform.localRotation (Quaternion)", "pattern": "\\brotation(_degrees)?\\b|\\bbasis\\b" },
+    { "id": "forward", "topic": "transform", "from": "-global_transform.basis.z (forward), Vector3.FORWARD = (0,0,-1)", "to": "transform.forward, Vector3.forward = (0,0,1)", "pattern": "basis\\.z|Vector3\\.FORWARD|Vector3\\.BACK" },
+    { "id": "look-at", "topic": "transform", "from": "look_at(target, Vector3.UP)", "to": "transform.LookAt(target)", "pattern": "\\blook_at\\(" },
+    { "id": "camera", "topic": "rendering", "from": "Camera3D (fov vertical, current = true)", "to": "Camera (fieldOfView vertical; tag MainCamera)", "pattern": "Camera3D" },
+    { "id": "lights", "topic": "rendering", "from": "DirectionalLight3D / OmniLight3D / SpotLight3D", "to": "Light with type Directional / Point / Spot", "pattern": "(Directional|Omni|Spot)Light3D", "notes": "Intensity units differ; retune light energy by eye." },
+    { "id": "mesh", "topic": "rendering", "from": "MeshInstance3D", "to": "MeshFilter + MeshRenderer (or the imported model prefab)", "pattern": "MeshInstance3D" },
+    { "id": "animation-player", "topic": "animation", "from": "AnimationPlayer.play(\"x\") / AnimationTree", "to": "Animator with an Animator Controller (state machine); animator.Play(\"x\") or parameters/triggers", "pattern": "AnimationPlayer|AnimationTree" },
+    { "id": "audio", "topic": "audio", "from": "AudioStreamPlayer / AudioStreamPlayer3D", "to": "AudioSource (spatialBlend 0 for 2D, 1 for 3D)", "pattern": "AudioStreamPlayer" },
+    { "id": "ui", "topic": "ui", "from": "Control, Label, Button, CanvasLayer", "to": "uGUI Canvas + TextMeshProUGUI/Button, or UI Toolkit", "pattern": "\\b(Control|Label|Button|CanvasLayer|TextureRect)\\b" },
+    { "id": "autoload", "topic": "architecture", "from": "Autoload singleton (project settings)", "to": "singleton MonoBehaviour with DontDestroyOnLoad, or a static class / ScriptableObject service", "pattern": "^\\[autoload\\]" },
+    { "id": "change-scene", "topic": "architecture", "from": "get_tree().change_scene_to_file(\"res://x.tscn\")", "to": "SceneManager.LoadScene(\"x\") (scene added to the build profile)", "pattern": "change_scene_to_(file|packed)\\(" },
+    { "id": "groups", "topic": "architecture", "from": "add_to_group(\"enemies\"), get_tree().get_nodes_in_group, is_in_group", "to": "Tags (CompareTag, FindGameObjectsWithTag) or a static registry list", "pattern": "(add_to_group|get_nodes_in_group|is_in_group)\\(" },
+    { "id": "resource", "topic": "data", "from": "custom Resource (.tres) with @export fields", "to": "ScriptableObject asset with serialized fields", "pattern": "extends\\s+Resource" },
+    { "id": "print", "topic": "debug", "from": "print(), push_warning(), push_error()", "to": "Debug.Log(), Debug.LogWarning(), Debug.LogError()", "pattern": "\\b(print|push_warning|push_error)\\(", "leftover": "^\\s*print\\(" },
+    { "id": "math", "topic": "math", "from": "lerp, clamp, deg_to_rad, randf, randi_range", "to": "Mathf.Lerp, Mathf.Clamp, Mathf.Deg2Rad *, Random.value, Random.Range(min, max + 1)", "pattern": "\\b(lerp|clamp|deg_to_rad|rad_to_deg|randf|randi_range|randf_range)\\(", "notes": "Random.Range(int, int) excludes the max; randi_range includes it." },
+    { "id": "time-scale", "topic": "time", "from": "Engine.time_scale", "to": "Time.timeScale", "pattern": "Engine\\.time_scale" },
+    { "id": "visibility", "topic": "scene tree", "from": "visible = false / hide()", "to": "renderer.enabled = false, or gameObject.SetActive(false) (also stops its scripts)", "pattern": "\\bvisible\\s*=|\\b(hide|show)\\(\\)" },
+    { "id": "shader", "topic": "rendering", "from": "Godot shading language (.gdshader)", "to": "Shader Graph or HLSL in a ShaderLab .shader (URP/HDRP specific)", "pattern": "shader_type\\s" },
+    { "id": "typed-arrays", "topic": "language", "from": "Array[int], Dictionary", "to": "List<int>, Dictionary<TKey, TValue>", "pattern": "\\bArray\\[|\\bDictionary\\b" },
+    { "id": "match", "topic": "language", "from": "match value:", "to": "switch (value) { case …: break; } or a switch expression", "pattern": "^\\s*match\\s" }
+  ]
+}