@cimplify/cli 0.15.3 → 0.17.0

package/dist/port-24R7ZNP4.mjs

@@ -0,0 +1,2408 @@
+#!/usr/bin/env node
+import { describeEvent, reportOutcome } from './chunk-OPX7KPOU.mjs';
+import { askAuthoring, modelFromEnv } from './chunk-74QZQSCL.mjs';
+import './chunk-BTNVYAC4.mjs';
+import './chunk-VHK7WBO3.mjs';
+import './chunk-454RQ6NR.mjs';
+import './chunk-JKECUAAV.mjs';
+import { titleFromName, materialize } from './chunk-ZG7NJLXN.mjs';
+import './chunk-HQPZQIWW.mjs';
+import './chunk-KQNZKV6E.mjs';
+import './chunk-N2WZJX5P.mjs';
+import './chunk-EYEMPIMP.mjs';
+import './chunk-BGM7CH5G.mjs';
+import './chunk-25ZPFHLF.mjs';
+import './chunk-SGT5IJVW.mjs';
+import { parseArgs, flagString, flagBool } from './chunk-XQAHREKO.mjs';
+import './chunk-GGPN4QYQ.mjs';
+import { CliError, CLI_ERROR_CODE, step, warn, success, info, dim, result } from './chunk-I7GEHLDD.mjs';
+import { promises, existsSync } from 'fs';
+import path from 'path';
+import { THREE_LIGHTS, threejsPortRequest, THREE_CONTROLS, THREE_GEOMETRIES, THREE_MATERIALS, THREE_TEXTURE_SLOTS, THREE_SIDES, THREE_MATH_HELPERS, THREE_VECTOR_METHODS, countSourceLines } from '@cimplify/sdk/interactives/authoring';
+import ts from 'typescript';
+
+var THREE_MODULE = "three";
+var THREE_ADDON_PREFIXES = ["three/addons/", "three/examples/jsm/"];
+var DROP = "\0DROP\0";
+var INDENT = "  ";
+var INFERENCE_PASSES = 4;
+var CAST_SHADOW_FLAG = 1;
+var RECEIVE_SHADOW_FLAG = 2;
+var DEFAULT_FOV = "50";
+var DEFAULT_NEAR = "0.1";
+var DEFAULT_FAR = "2000";
+var HEX_RADIX = 16;
+var SHORT_HEX_LENGTH = 3;
+var LONG_HEX_LENGTH = 6;
+var COLOR_CHANNEL_MAX = 255;
+var ROUGHNESS_DIGITS = 3;
+var PHONG_SHININESS_DEFAULT = 30;
+var SHININESS_OFFSET = 2;
+var AXIS_NAMES = { x: "AXIS_X", y: "AXIS_Y", z: "AXIS_Z" };
+var TRANSFORM_ATTRIBUTES = { position: "Position", scale: "Scale", rotation: "Rotation" };
+var KEY_EVENTS = { keydown: "keydown", keypress: "keydown", keyup: "keyup" };
+var POINTER_EVENTS = {
+  pointerdown: "pointerdown",
+  mousedown: "pointerdown",
+  touchstart: "pointerdown",
+  pointerup: "pointerup",
+  mouseup: "pointerup",
+  touchend: "pointerup",
+  click: "pointerup"
+};
+var DROPPED_EVENTS = /* @__PURE__ */ new Set(["resize", "orientationchange"]);
+var LISTENER_TARGETS = /* @__PURE__ */ new Set(["window", "document"]);
+var HUD_PROPERTIES = /* @__PURE__ */ new Set(["textContent", "innerText", "innerHTML"]);
+var COLOR_PROPERTIES = /* @__PURE__ */ new Set(["color", "emissive", "sheenColor", "specularColor", "attenuationColor"]);
+var ENTITY_CLASSES = /* @__PURE__ */ new Set(["Mesh", "Group", "Object3D", "PerspectiveCamera", "OrthographicCamera", ...Object.keys(THREE_LIGHTS)]);
+var DROPPED_RENDERER_CLASSES = /* @__PURE__ */ new Set(["WebGLRenderer", "WebGPURenderer"]);
+var CAMERA_DROPPED_MEMBERS = /* @__PURE__ */ new Set(["aspect", "updateProjectionMatrix"]);
+var HANDLED_ENTITY_MEMBERS = /* @__PURE__ */ new Set(["material", "visible", "castShadow", "receiveShadow", "shadow", "target", "aspect", "updateProjectionMatrix", "updateMatrix", "updateMatrixWorld"]);
+var MATRIX_UPDATES = /* @__PURE__ */ new Set(["updateMatrix", "updateMatrixWorld"]);
+var ACTION_PASSTHROUGH = /* @__PURE__ */ new Set(["play", "stop", "fadeIn", "fadeOut", "reset", "setEffectiveTimeScale", "setEffectiveWeight", "isRunning"]);
+var TONE_MAPPINGS = {
+  NoToneMapping: "none",
+  LinearToneMapping: "linear",
+  ReinhardToneMapping: "reinhard",
+  CineonToneMapping: "cineon",
+  ACESFilmicToneMapping: "aces",
+  AgXToneMapping: "agx",
+  NeutralToneMapping: "neutral"
+};
+var LOOP_MODES = { LoopOnce: "false", LoopRepeat: "true", LoopPingPong: "true" };
+var NAMED_COLORS = {
+  black: 0,
+  white: 16777215,
+  red: 16711680,
+  green: 32768,
+  lime: 65280,
+  blue: 255,
+  yellow: 16776960,
+  cyan: 65535,
+  aqua: 65535,
+  magenta: 16711935,
+  fuchsia: 16711935,
+  orange: 16753920,
+  purple: 8388736,
+  pink: 16761035,
+  brown: 10824234,
+  gray: 8421504,
+  grey: 8421504,
+  silver: 12632256,
+  gold: 16766720,
+  navy: 128,
+  teal: 32896,
+  skyblue: 8900331,
+  maroon: 8388608,
+  olive: 8421376
+};
+var COMMON_MATERIAL_PROPERTIES = ["transparent", "opacity", "side", "depthTest", "depthWrite", "wireframe", "alphaTest", "vertexColors"];
+var MATERIAL_PROPERTIES_BY_KIND = {
+  standard: /* @__PURE__ */ new Set([...COMMON_MATERIAL_PROPERTIES, "color", "roughness", "metalness", "emissive", "emissiveIntensity", "map", "normalMap", "roughnessMap", "metalnessMap", "emissiveMap", "aoMap", "flatShading"]),
+  physical: /* @__PURE__ */ new Set([
+    ...COMMON_MATERIAL_PROPERTIES,
+    "color",
+    "roughness",
+    "metalness",
+    "emissive",
+    "emissiveIntensity",
+    "map",
+    "normalMap",
+    "roughnessMap",
+    "metalnessMap",
+    "emissiveMap",
+    "aoMap",
+    "flatShading",
+    "clearcoat",
+    "clearcoatRoughness",
+    "transmission",
+    "ior",
+    "thickness",
+    "sheen",
+    "sheenColor",
+    "sheenRoughness",
+    "iridescence",
+    "anisotropy",
+    "attenuationColor",
+    "attenuationDistance",
+    "specularColor",
+    "specularIntensity"
+  ]),
+  unlit: /* @__PURE__ */ new Set([...COMMON_MATERIAL_PROPERTIES, "color", "map"]),
+  toon: /* @__PURE__ */ new Set([...COMMON_MATERIAL_PROPERTIES, "color", "map", "gradientMap", "normalMap", "emissive", "emissiveIntensity", "emissiveMap", "aoMap"]),
+  matcap: /* @__PURE__ */ new Set([...COMMON_MATERIAL_PROPERTIES, "color", "map", "matcap", "normalMap", "flatShading"])
+};
+var KEY_CODE = /^(Key[A-Z]|Digit[0-9]|Arrow(Up|Down|Left|Right)|Space|Enter|Escape|Tab|Backspace|Shift(Left|Right)|Control(Left|Right)|Alt(Left|Right)|Numpad[0-9]|F[1-9]|F1[0-2])$/;
+var KEY_ALIASES = {
+  " ": "Space",
+  Shift: "ShiftLeft",
+  Control: "ControlLeft",
+  Alt: "AltLeft",
+  Esc: "Escape",
+  Up: "ArrowUp",
+  Down: "ArrowDown",
+  Left: "ArrowLeft",
+  Right: "ArrowRight"
+};
+var SINGLE_LETTER = /^[a-zA-Z]$/;
+var SINGLE_DIGIT = /^[0-9]$/;
+var HEX_COLOR = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+var SIMPLE_OPERAND = /^[A-Za-z_$][\w$]*$|^-?\d+(\.\d+)?$/;
+var BLANK_RUNS = /\n{3,}/g;
+var DROPPED_KINDS = /* @__PURE__ */ new Set(["scene", "renderer", "clock", "gltfLoader", "textureLoader"]);
+var PRIMITIVE_KINDS = /* @__PURE__ */ new Set(["number", "string", "boolean"]);
+var SCENE_LOCALS = /* @__PURE__ */ new Set(["game", "port"]);
+var RESERVED_MEMBERS = /* @__PURE__ */ new Set(["name", "game", "port", "assets", "enter", "exit", "fixedUpdate", "update", "systems", "constructor"]);
+var MEMBER_SUFFIX = "State";
+var SIMPLE_REFERENCE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)*$/;
+function codeOfKey(value) {
+  if (KEY_CODE.test(value)) return value;
+  const alias = KEY_ALIASES[value];
+  if (alias !== void 0) return alias;
+  if (SINGLE_LETTER.test(value)) return `Key${value.toUpperCase()}`;
+  if (SINGLE_DIGIT.test(value)) return `Digit${value}`;
+  return null;
+}
+function sceneClassName(sceneName) {
+  const words = sceneName.split(/[^A-Za-z0-9]+/).filter((w) => w.length > 0);
+  const base = words.map((w) => w[0].toUpperCase() + w.slice(1)).join("");
+  return `${/^[A-Za-z]/.test(base) ? base : `Ported${base}`}Scene`;
+}
+function colorLiteral(value) {
+  const named = NAMED_COLORS[value.toLowerCase()];
+  if (named !== void 0) return named;
+  const hex = HEX_COLOR.exec(value);
+  if (hex === null) return null;
+  const digits = hex[1];
+  const full = digits.length === SHORT_HEX_LENGTH ? digits.split("").map((d) => d + d).join("") : digits;
+  return full.length === LONG_HEX_LENGTH ? Number.parseInt(full, HEX_RADIX) : null;
+}
+function hexText(value) {
+  return `0x${value.toString(HEX_RADIX).padStart(LONG_HEX_LENGTH, "0")}`;
+}
+function elementOf(kind) {
+  if (kind.endsWith("[]") || kind.endsWith("{}")) return kind.slice(0, -2);
+  return "unknown";
+}
+function isArrayKind(kind) {
+  return kind.endsWith("[]");
+}
+function isRecordKind(kind) {
+  return kind.endsWith("{}");
+}
+function memoryHost(fileName, sourceFile) {
+  return {
+    getSourceFile: (name) => name === fileName ? sourceFile : void 0,
+    getDefaultLibFileName: () => "lib.d.ts",
+    writeFile: () => void 0,
+    getCurrentDirectory: () => "/",
+    getCanonicalFileName: (name) => name,
+    useCaseSensitiveFileNames: () => true,
+    getNewLine: () => "\n",
+    fileExists: (name) => name === fileName,
+    readFile: () => void 0
+  };
+}
+function scriptKind(path2) {
+  if (path2.endsWith(".ts")) return ts.ScriptKind.TS;
+  if (path2.endsWith(".tsx")) return ts.ScriptKind.TSX;
+  if (path2.endsWith(".jsx")) return ts.ScriptKind.JSX;
+  return ts.ScriptKind.JS;
+}
+function importsThree(source) {
+  return /from\s+["']three(["']|\/)/.test(source);
+}
+var ThreeModuleConverter = class {
+  constructor(path2, source, options) {
+    this.path = path2;
+    this.options = options;
+    this.text = source;
+    this.sf = ts.createSourceFile(path2, source, ts.ScriptTarget.Latest, true, scriptKind(path2));
+    const program = ts.createProgram({
+      rootNames: [path2],
+      options: { allowJs: true, noLib: true, noResolve: true, types: [], target: ts.ScriptTarget.Latest },
+      host: memoryHost(path2, this.sf)
+    });
+    this.checker = program.getTypeChecker();
+  }
+  path;
+  options;
+  sf;
+  checker;
+  text;
+  bindings = /* @__PURE__ */ new Map();
+  functions = /* @__PURE__ */ new Map();
+  threeNamespaces = /* @__PURE__ */ new Set();
+  threeNames = /* @__PURE__ */ new Map();
+  residueItems = [];
+  residueKeys = /* @__PURE__ */ new Set();
+  areaCounts = {};
+  gameImports = /* @__PURE__ */ new Set();
+  gameTypeImports = /* @__PURE__ */ new Set();
+  kitImports = /* @__PURE__ */ new Set(["ThreePort"]);
+  kitTypeImports = /* @__PURE__ */ new Set(["PortAssetReader"]);
+  assetPaths = /* @__PURE__ */ new Set();
+  features = /* @__PURE__ */ new Set();
+  keyCodes = /* @__PURE__ */ new Set();
+  keyRecords = /* @__PURE__ */ new Set();
+  hudSlots = /* @__PURE__ */ new Map();
+  foldedStatements = /* @__PURE__ */ new Set();
+  loopReachable = /* @__PURE__ */ new Set();
+  fields = /* @__PURE__ */ new Set();
+  methods = /* @__PURE__ */ new Set();
+  moduleConstants = /* @__PURE__ */ new Set();
+  memberNames = /* @__PURE__ */ new Map();
+  env = { background: null, fog: null, shadows: null, toneMapping: null, exposure: null };
+  loopFunction = null;
+  loopHasTime = false;
+  keyListeners = 0;
+  touchHandled = false;
+  setupDepth = 0;
+  convert() {
+    this.collectImports();
+    this.collectBindings();
+    for (let pass = 0; pass < INFERENCE_PASSES; pass++) this.inferPass(this.sf);
+    this.findLoop();
+    this.collectKeys();
+    this.collectHudSlots();
+    const scene = this.emitScene();
+    this.adviseTouch();
+    let converted = 0;
+    for (const count of Object.values(this.areaCounts)) converted += count ?? 0;
+    return {
+      scene,
+      residue: [...this.residueItems].sort((a, b) => a.line - b.line || a.column - b.column),
+      converted,
+      convertedByArea: { ...this.areaCounts },
+      assets: [...this.assetPaths].sort(),
+      engineFeatures: [...this.features].sort(),
+      loopFound: this.loopFunction !== null
+    };
+  }
+  count(area) {
+    this.areaCounts[area] = (this.areaCounts[area] ?? 0) + 1;
+  }
+  residue(node, kind, area, construct, hint) {
+    const start = node.getStart(this.sf);
+    const key = `${start}:${construct}`;
+    if (this.residueKeys.has(key)) return;
+    this.residueKeys.add(key);
+    const at = this.sf.getLineAndCharacterOfPosition(start);
+    this.residueItems.push({
+      id: `R${this.residueItems.length + 1}`,
+      kind,
+      area,
+      construct,
+      file: this.path,
+      line: at.line + 1,
+      column: at.character + 1,
+      source: node.getText(this.sf).slice(0, 240),
+      hint
+    });
+  }
+  symbolOf(node) {
+    return this.checker.getSymbolAtLocation(node) ?? null;
+  }
+  collectImports() {
+    for (const statement of this.sf.statements) {
+      if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+      const from = statement.moduleSpecifier.text;
+      const isThree = from === THREE_MODULE || THREE_ADDON_PREFIXES.some((p) => from.startsWith(p));
+      if (!isThree) continue;
+      const clause = statement.importClause;
+      if (clause === void 0) continue;
+      const bindings = clause.namedBindings;
+      if (bindings !== void 0 && ts.isNamespaceImport(bindings)) {
+        const symbol = this.symbolOf(bindings.name);
+        if (symbol !== null) this.threeNamespaces.add(symbol);
+      }
+      if (bindings !== void 0 && ts.isNamedImports(bindings)) {
+        for (const element of bindings.elements) {
+          const symbol = this.symbolOf(element.name);
+          if (symbol !== null) this.threeNames.set(symbol, (element.propertyName ?? element.name).text);
+        }
+      }
+      if (clause.name !== void 0) {
+        const symbol = this.symbolOf(clause.name);
+        if (symbol !== null) this.threeNamespaces.add(symbol);
+      }
+    }
+  }
+  threeName(expr) {
+    if (ts.isIdentifier(expr)) {
+      const symbol = this.symbolOf(expr);
+      return symbol === null ? null : this.threeNames.get(symbol) ?? null;
+    }
+    if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression)) {
+      const symbol = this.symbolOf(expr.expression);
+      if (symbol !== null && this.threeNamespaces.has(symbol)) return expr.name.text;
+    }
+    return null;
+  }
+  threeMember(expr) {
+    if (!ts.isPropertyAccessExpression(expr)) return null;
+    const owner = this.threeName(expr.expression);
+    return owner === null ? null : [owner, expr.name.text];
+  }
+  isThreeRoot(expr) {
+    if (!ts.isIdentifier(expr)) return false;
+    const symbol = this.symbolOf(expr);
+    return symbol !== null && (this.threeNamespaces.has(symbol) || this.threeNames.has(symbol));
+  }
+  binding(symbol, name) {
+    let found = this.bindings.get(symbol);
+    if (found === void 0) {
+      found = { symbol, name, kind: "unknown", shadows: 0, shadowMapSize: null, material: null, light: null, target: null, controlsClass: null, camera: null };
+      this.bindings.set(symbol, found);
+    }
+    return found;
+  }
+  bindingOf(expr) {
+    if (!ts.isIdentifier(expr)) return null;
+    const symbol = this.symbolOf(expr);
+    return symbol === null ? null : this.bindings.get(symbol) ?? null;
+  }
+  collectBindings() {
+    const visit = (node) => {
+      if ((ts.isVariableDeclaration(node) || ts.isParameter(node)) && ts.isIdentifier(node.name)) {
+        const symbol = this.symbolOf(node.name);
+        if (symbol !== null) this.binding(symbol, node.name.text);
+      }
+      if (ts.isFunctionDeclaration(node) && node.name !== void 0) {
+        const symbol = this.symbolOf(node.name);
+        if (symbol !== null) this.functions.set(symbol, { returnKind: "unknown" });
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(this.sf);
+  }
+  setKind(symbol, kind) {
+    if (symbol === null || kind === "unknown") return;
+    const binding = this.bindings.get(symbol);
+    if (binding === void 0) return;
+    if (binding.kind === "unknown" || binding.kind === "unknown[]" || binding.kind === "unknown{}") binding.kind = kind;
+  }
+  functionSymbolOf(callee) {
+    if (!ts.isIdentifier(callee)) return null;
+    const symbol = this.symbolOf(callee);
+    return symbol !== null && this.functions.has(symbol) ? symbol : null;
+  }
+  declarationOf(symbol) {
+    return symbol.valueDeclaration ?? symbol.declarations?.[0] ?? null;
+  }
+  paramSymbol(fn, index) {
+    if (!ts.isFunctionLike(fn)) return null;
+    const param = fn.parameters[index];
+    if (param === void 0 || !ts.isIdentifier(param.name)) return null;
+    return this.symbolOf(param.name);
+  }
+  callbackOf(arg) {
+    if (arg === void 0) return null;
+    if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) return arg;
+    if (ts.isIdentifier(arg)) {
+      const symbol = this.symbolOf(arg);
+      const decl = symbol === null ? null : this.declarationOf(symbol);
+      if (decl !== null && ts.isFunctionDeclaration(decl)) return decl;
+    }
+    return null;
+  }
+  inferPass(root) {
+    const visit = (node) => {
+      if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer !== void 0) {
+        this.setKind(this.symbolOf(node.name), this.kindOf(node.initializer));
+        if (ts.isNewExpression(node.initializer)) this.recordConstruction(this.symbolOf(node.name), node.initializer);
+      }
+      if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+        if (ts.isIdentifier(node.left)) {
+          this.setKind(this.symbolOf(node.left), this.kindOf(node.right));
+          if (ts.isNewExpression(node.right)) this.recordConstruction(this.symbolOf(node.left), node.right);
+        }
+        if (ts.isElementAccessExpression(node.left) && ts.isIdentifier(node.left.expression)) {
+          const value = this.kindOf(node.right);
+          const symbol = this.symbolOf(node.left.expression);
+          if (value !== "unknown" && symbol !== null) {
+            const binding = this.bindings.get(symbol);
+            if (binding !== void 0 && binding.kind === "unknown{}") binding.kind = `${value}{}`;
+            if (binding !== void 0 && binding.kind === "unknown[]") binding.kind = `${value}[]`;
+          }
+        }
+      }
+      if (ts.isForOfStatement(node) && ts.isVariableDeclarationList(node.initializer)) {
+        const decl = node.initializer.declarations[0];
+        if (decl !== void 0 && ts.isIdentifier(decl.name)) this.setKind(this.symbolOf(decl.name), elementOf(this.kindOf(node.expression)));
+      }
+      if (ts.isCallExpression(node)) this.inferCall(node);
+      if (ts.isReturnStatement(node) && node.expression !== void 0) {
+        const fn = this.enclosingFunctionDeclaration(node);
+        if (fn !== null && fn.name !== void 0) {
+          const symbol = this.symbolOf(fn.name);
+          const info2 = symbol === null ? void 0 : this.functions.get(symbol);
+          const kind = this.kindOf(node.expression);
+          if (info2 !== void 0 && info2.returnKind === "unknown") info2.returnKind = kind;
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(root);
+  }
+  enclosingFunctionDeclaration(node) {
+    let current = node.parent;
+    while (current !== void 0) {
+      if (ts.isArrowFunction(current) || ts.isFunctionExpression(current)) return null;
+      if (ts.isFunctionDeclaration(current)) return current;
+      current = current.parent;
+    }
+    return null;
+  }
+  recordConstruction(symbol, expr) {
+    if (symbol === null) return;
+    const binding = this.bindings.get(symbol);
+    if (binding === void 0) return;
+    const name = this.threeName(expr.expression);
+    if (name === null) return;
+    const args = expr.arguments ?? [];
+    if (name === "Mesh" && args[1] !== void 0 && ts.isIdentifier(args[1])) binding.material = this.symbolOf(args[1]);
+    const light = THREE_LIGHTS[name];
+    if (light !== void 0) binding.light = light.light;
+    const controls = THREE_CONTROLS[name];
+    if (controls !== void 0) {
+      binding.controlsClass = controls;
+      binding.camera = args[0] ?? null;
+    }
+  }
+  inferCall(node) {
+    const fn = this.functionSymbolOf(node.expression);
+    if (fn !== null) {
+      const decl = this.declarationOf(fn);
+      if (decl !== null) node.arguments.forEach((arg, i) => this.setKind(this.paramSymbol(decl, i), this.kindOf(arg)));
+    }
+    if (!ts.isPropertyAccessExpression(node.expression)) return;
+    const method = node.expression.name.text;
+    const receiver = node.expression.expression;
+    const receiverKind = this.kindOf(receiver);
+    if (method === "push" && ts.isIdentifier(receiver)) {
+      const symbol = this.symbolOf(receiver);
+      const binding = symbol === null ? void 0 : this.bindings.get(symbol);
+      const kind = node.arguments[0] === void 0 ? "unknown" : this.kindOf(node.arguments[0]);
+      if (binding !== void 0 && (binding.kind === "unknown" || binding.kind === "unknown[]") && kind !== "unknown") binding.kind = `${kind}[]`;
+    }
+    if ((method === "forEach" || method === "map" || method === "filter" || method === "some" || method === "every") && isArrayKind(receiverKind)) {
+      this.setKind(this.paramSymbol(this.callbackOf(node.arguments[0]) ?? node, 0), elementOf(receiverKind));
+    }
+    if (method === "load" && receiverKind === "gltfLoader") this.setKind(this.paramSymbol(this.callbackOf(node.arguments[1]) ?? node, 0), "gltf");
+    if (method === "then" && ts.isCallExpression(receiver) && ts.isPropertyAccessExpression(receiver.expression) && receiver.expression.name.text === "loadAsync") {
+      if (this.kindOf(receiver.expression.expression) === "gltfLoader") this.setKind(this.paramSymbol(this.callbackOf(node.arguments[0]) ?? node, 0), "gltf");
+    }
+    if (method === "addEventListener" && node.arguments[0] !== void 0 && ts.isStringLiteralLike(node.arguments[0])) {
+      const type = node.arguments[0].text;
+      const handler = this.callbackOf(node.arguments[1]);
+      if (handler !== null && KEY_EVENTS[type] !== void 0) this.setKind(this.paramSymbol(handler, 0), "keyEvent");
+      if (handler !== null && POINTER_EVENTS[type] !== void 0) this.setKind(this.paramSymbol(handler, 0), "pointerEvent");
+    }
+  }
+  kindOf(expr) {
+    if (ts.isParenthesizedExpression(expr) || ts.isNonNullExpression(expr) || ts.isAsExpression(expr)) return this.kindOf(expr.expression);
+    if (ts.isNumericLiteral(expr)) return "number";
+    if (ts.isStringLiteralLike(expr) || ts.isTemplateExpression(expr)) return "string";
+    if (expr.kind === ts.SyntaxKind.TrueKeyword || expr.kind === ts.SyntaxKind.FalseKeyword) return "boolean";
+    if (ts.isArrayLiteralExpression(expr)) {
+      const first = expr.elements[0];
+      return first === void 0 ? "unknown[]" : `${this.kindOf(first)}[]`;
+    }
+    if (ts.isObjectLiteralExpression(expr)) return expr.properties.length === 0 ? "unknown{}" : "unknown";
+    if (ts.isPrefixUnaryExpression(expr)) return expr.operator === ts.SyntaxKind.ExclamationToken ? "boolean" : "number";
+    if (ts.isPostfixUnaryExpression(expr)) return "number";
+    if (ts.isConditionalExpression(expr)) {
+      const whenTrue = this.kindOf(expr.whenTrue);
+      return whenTrue !== "unknown" ? whenTrue : this.kindOf(expr.whenFalse);
+    }
+    if (ts.isBinaryExpression(expr)) return this.binaryKind(expr);
+    if (ts.isIdentifier(expr)) {
+      const binding = this.bindingOf(expr);
+      if (binding !== null) return binding.kind;
+      return this.isThreeRoot(expr) ? "three" : "unknown";
+    }
+    if (ts.isNewExpression(expr)) return this.newKind(expr);
+    if (ts.isElementAccessExpression(expr)) {
+      const owner = this.kindOf(expr.expression);
+      return isArrayKind(owner) || isRecordKind(owner) ? elementOf(owner) : "unknown";
+    }
+    if (ts.isPropertyAccessExpression(expr)) return this.propertyKind(expr);
+    if (ts.isCallExpression(expr)) return this.callKind(expr);
+    return "unknown";
+  }
+  binaryKind(expr) {
+    const op = expr.operatorToken.kind;
+    if (op === ts.SyntaxKind.EqualsEqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsEqualsToken || op === ts.SyntaxKind.EqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsToken || op === ts.SyntaxKind.LessThanToken || op === ts.SyntaxKind.GreaterThanToken || op === ts.SyntaxKind.LessThanEqualsToken || op === ts.SyntaxKind.GreaterThanEqualsToken) {
+      return "boolean";
+    }
+    if (op === ts.SyntaxKind.AmpersandAmpersandToken || op === ts.SyntaxKind.BarBarToken || op === ts.SyntaxKind.QuestionQuestionToken) {
+      const right = this.kindOf(expr.right);
+      return right !== "unknown" ? right : this.kindOf(expr.left);
+    }
+    if (op === ts.SyntaxKind.EqualsToken) return this.kindOf(expr.right);
+    if (op === ts.SyntaxKind.PlusToken) {
+      const left = this.kindOf(expr.left);
+      const right = this.kindOf(expr.right);
+      return left === "string" || right === "string" ? "string" : "number";
+    }
+    return "number";
+  }
+  newKind(expr) {
+    const name = this.threeName(expr.expression);
+    if (name === null) {
+      if (ts.isIdentifier(expr.expression) && expr.expression.text === "Array") return "unknown[]";
+      return "unknown";
+    }
+    if (ENTITY_CLASSES.has(name)) return "entity";
+    if (THREE_GEOMETRIES[name] !== void 0) return "geometry";
+    if (THREE_MATERIALS[name] !== void 0) return "material";
+    if (THREE_CONTROLS[name] !== void 0) return "controls";
+    switch (name) {
+      case "Scene":
+        return "scene";
+      case "Clock":
+        return "clock";
+      case "GLTFLoader":
+        return "gltfLoader";
+      case "TextureLoader":
+        return "textureLoader";
+      case "AnimationMixer":
+        return "mixer";
+      case "Vector3":
+        return "vector";
+      case "Quaternion":
+        return "quat";
+      case "Color":
+        return "number";
+      default:
+        return DROPPED_RENDERER_CLASSES.has(name) ? "renderer" : "unknown";
+    }
+  }
+  propertyKind(expr) {
+    const name = expr.name.text;
+    const owner = expr.expression;
+    if (ts.isIdentifier(owner) && owner.text === "Math") return "number";
+    const ownerKind = this.kindOf(owner);
+    if (ownerKind === "gltf" && name === "scene") return "entity";
+    if (ownerKind === "gltf" && name === "animations") return "string[]";
+    if (ownerKind === "renderer" && name === "domElement") return "domElement";
+    if (ownerKind === "keyEvent" && (name === "code" || name === "key")) return "string";
+    if (ownerKind === "pointerEvent") return "number";
+    if (ownerKind === "vector" && (name === "x" || name === "y" || name === "z")) return "number";
+    if (ownerKind === "clock" && name === "elapsedTime") return "number";
+    if (ownerKind === "string[]" && name === "length") return "number";
+    if (isArrayKind(ownerKind) && name === "length") return "number";
+    if (isRecordKind(ownerKind)) return elementOf(ownerKind);
+    if (ts.isPropertyAccessExpression(owner) && this.kindOf(owner.expression) === "entity" && TRANSFORM_ATTRIBUTES[owner.name.text] !== void 0 && AXIS_NAMES[name] !== void 0) return "number";
+    if (ownerKind === "entity" && name === "position") return "vector";
+    return "unknown";
+  }
+  callKind(expr) {
+    const fn = this.functionSymbolOf(expr.expression);
+    if (fn !== null) return this.functions.get(fn)?.returnKind ?? "unknown";
+    if (ts.isIdentifier(expr.expression) && (expr.expression.text === "Number" || expr.expression.text === "parseFloat" || expr.expression.text === "parseInt")) return "number";
+    if (ts.isIdentifier(expr.expression) && expr.expression.text === "String") return "string";
+    if (!ts.isPropertyAccessExpression(expr.expression)) return "unknown";
+    const method = expr.expression.name.text;
+    const receiver = expr.expression.expression;
+    if (ts.isIdentifier(receiver) && receiver.text === "Math") return "number";
+    if (ts.isIdentifier(receiver) && receiver.text === "document" && (method === "getElementById" || method === "querySelector")) return "hud";
+    const member = this.threeMember(expr.expression);
+    if (member !== null && member[0] === "MathUtils") return "number";
+    const receiverKind = this.kindOf(receiver);
+    if (receiverKind === "mixer" && method === "clipAction") return "action";
+    if (receiverKind === "textureLoader" && method === "load") return "texture";
+    if (ts.isNewExpression(receiver) && this.threeName(receiver.expression) === "TextureLoader" && method === "load") return "texture";
+    if (receiverKind === "clock") return "number";
+    if (receiverKind === "controls" && method === "getObject") return "entity";
+    if (receiverKind === "vector" && (method === "length" || method === "lengthSq" || method === "dot" || method === "distanceTo" || method === "distanceToSquared" || method === "angleTo")) return "number";
+    if (receiverKind === "vector") return "vector";
+    if (ts.isPropertyAccessExpression(receiver) && this.kindOf(receiver.expression) === "entity" && (method === "distanceTo" || method === "distanceToSquared")) return "number";
+    if (receiverKind === "string" || receiverKind === "number") return receiverKind;
+    return "unknown";
+  }
+  typeOf(kind, binding) {
+    if (isArrayKind(kind)) {
+      const element = this.typeOf(elementOf(kind), null);
+      return element === null ? null : `${element}[]`;
+    }
+    if (isRecordKind(kind)) {
+      const element = this.typeOf(elementOf(kind), null);
+      return element === null ? null : `Record<string, ${element}>`;
+    }
+    switch (kind) {
+      case "number":
+      case "string":
+      case "boolean":
+        return kind;
+      case "entity":
+      case "mixer":
+        this.gameTypeImports.add("Entity");
+        return "Entity";
+      case "geometry":
+        this.gameTypeImports.add("GeometryId");
+        return "GeometryId";
+      case "material":
+        this.gameTypeImports.add("MaterialId");
+        return "MaterialId";
+      case "texture":
+        this.gameTypeImports.add("TextureId");
+        return "Promise<TextureId>";
+      case "vector":
+        this.gameImports.add("Vec3");
+        return "Vec3";
+      case "quat":
+        this.gameImports.add("Quat");
+        return "Quat";
+      case "hud":
+        this.gameTypeImports.add("HudSlot");
+        return "HudSlot";
+      case "action":
+        this.kitTypeImports.add("PortClipAction");
+        return "PortClipAction";
+      case "gltf":
+        this.gameTypeImports.add("ModelInfo");
+        return "ModelInfo";
+      case "keyEvent":
+        this.kitTypeImports.add("PortKeyEvent");
+        return "PortKeyEvent";
+      case "pointerEvent":
+        this.kitTypeImports.add("PortPointerEvent");
+        return "PortPointerEvent";
+      case "controls":
+        if (binding?.controlsClass) {
+          this.kitImports.add(binding.controlsClass);
+          return binding.controlsClass;
+        }
+        return null;
+      default:
+        return null;
+    }
+  }
+  findLoop() {
+    const visit = (node) => {
+      if (ts.isCallExpression(node)) {
+        const callee = node.expression;
+        const isRaf = ts.isIdentifier(callee) && callee.text === "requestAnimationFrame";
+        const isRafOnWindow = ts.isPropertyAccessExpression(callee) && callee.name.text === "requestAnimationFrame";
+        const isLoop = ts.isPropertyAccessExpression(callee) && callee.name.text === "setAnimationLoop" && this.kindOf(callee.expression) === "renderer";
+        const arg = node.arguments[0];
+        if ((isRaf || isRafOnWindow || isLoop) && arg !== void 0 && ts.isIdentifier(arg)) {
+          const symbol = this.symbolOf(arg);
+          if (symbol !== null && this.functions.has(symbol) && this.loopFunction === null) this.loopFunction = symbol;
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(this.sf);
+    if (this.loopFunction === null) return;
+    const decl = this.declarationOf(this.loopFunction);
+    if (decl !== null && ts.isFunctionDeclaration(decl)) {
+      this.loopHasTime = decl.parameters.length > 0;
+      const time = this.paramSymbol(decl, 0);
+      if (time !== null) this.setKind(time, "number");
+      this.markReachable(decl);
+    }
+  }
+  markReachable(fn) {
+    if (this.loopReachable.has(fn)) return;
+    this.loopReachable.add(fn);
+    const visit = (node) => {
+      if (ts.isCallExpression(node)) {
+        const symbol = this.functionSymbolOf(node.expression);
+        const decl = symbol === null ? null : this.declarationOf(symbol);
+        if (decl !== null && ts.isFunctionDeclaration(decl)) this.markReachable(decl);
+      }
+      ts.forEachChild(node, visit);
+    };
+    if (fn.body !== void 0) visit(fn.body);
+  }
+  isKeyHandlerBody(node) {
+    let current = node;
+    while (current !== void 0) {
+      if (ts.isFunctionLike(current)) {
+        const param = current.parameters[0];
+        if (param !== void 0 && ts.isIdentifier(param.name)) {
+          const symbol = this.symbolOf(param.name);
+          if (symbol !== null && this.bindings.get(symbol)?.kind === "keyEvent") return true;
+        }
+      }
+      current = current.parent;
+    }
+    return false;
+  }
+  collectKeys() {
+    const visit = (node) => {
+      if (ts.isElementAccessExpression(node) && ts.isIdentifier(node.expression) && this.isKeyHandlerBody(node)) {
+        const index = node.argumentExpression;
+        if (ts.isPropertyAccessExpression(index) && this.kindOf(index.expression) === "keyEvent") {
+          const symbol = this.symbolOf(node.expression);
+          if (symbol !== null) this.keyRecords.add(symbol);
+        }
+      }
+      if (ts.isStringLiteralLike(node) && this.isKeyHandlerBody(node)) {
+        const code = codeOfKey(node.text);
+        if (code !== null && !ts.isCallExpression(node.parent)) this.keyCodes.add(code);
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(this.sf);
+    const records = (node) => {
+      if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
+        const symbol = this.symbolOf(node.expression);
+        const code = codeOfKey(node.name.text);
+        if (symbol !== null && this.keyRecords.has(symbol) && code !== null) this.keyCodes.add(code);
+      }
+      if (ts.isElementAccessExpression(node) && ts.isIdentifier(node.expression) && ts.isStringLiteralLike(node.argumentExpression)) {
+        const symbol = this.symbolOf(node.expression);
+        const code = codeOfKey(node.argumentExpression.text);
+        if (symbol !== null && this.keyRecords.has(symbol) && code !== null) this.keyCodes.add(code);
+      }
+      ts.forEachChild(node, records);
+    };
+    records(this.sf);
+    for (const symbol of this.keyRecords) {
+      const binding = this.bindings.get(symbol);
+      if (binding !== void 0 && (binding.kind === "unknown{}" || binding.kind === "unknown")) binding.kind = "boolean{}";
+    }
+  }
+  collectHudSlots() {
+    const visit = (node) => {
+      if (ts.isCallExpression(node) && this.hudIdOf(node) !== null) {
+        const id = this.hudIdOf(node) ?? "";
+        const parent = node.parent;
+        const declared = ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name);
+        if (!declared && !this.hudSlots.has(id)) this.hudSlots.set(id, `hud${id.replace(/(^|[^A-Za-z0-9]+)([A-Za-z0-9])/g, (_m, _s, c) => c.toUpperCase())}`);
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(this.sf);
+  }
+  hudIdOf(node) {
+    if (!ts.isPropertyAccessExpression(node.expression)) return null;
+    const receiver = node.expression.expression;
+    if (!ts.isIdentifier(receiver) || receiver.text !== "document") return null;
+    const arg = node.arguments[0];
+    if (arg === void 0 || !ts.isStringLiteralLike(arg)) return null;
+    if (node.expression.name.text === "getElementById") return arg.text;
+    if (node.expression.name.text === "querySelector" && arg.text.startsWith("#")) return arg.text.slice(1);
+    return null;
+  }
+  adviseTouch() {
+    if (this.keyListeners === 0 || this.touchHandled) return;
+    const first = this.firstKeyListener();
+    if (first === null) return;
+    this.residue(
+      first,
+      "advisory",
+      "input",
+      "keyboard only input",
+      'Phones have no keyboard: add a touch path. For moving a character use thirdPersonCharacter or firstPerson from the controls topic; otherwise define virtual bindings ({ device: "virtual", control }) next to the keys and draw them with TouchControls.'
+    );
+  }
+  firstKeyListener() {
+    let found = null;
+    const visit = (node) => {
+      if (found !== null) return;
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "addEventListener") {
+        const arg = node.arguments[0];
+        if (arg !== void 0 && ts.isStringLiteralLike(arg) && KEY_EVENTS[arg.text] !== void 0) found = node;
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(this.sf);
+    return found;
+  }
+  classify() {
+    for (const statement of this.sf.statements) {
+      if (ts.isFunctionDeclaration(statement) && statement.name !== void 0) {
+        const symbol = this.symbolOf(statement.name);
+        if (symbol !== null) this.claimMember(symbol, statement.name.text, this.methods);
+        continue;
+      }
+      if (!ts.isVariableStatement(statement)) continue;
+      const constant = (statement.declarationList.flags & ts.NodeFlags.Const) !== 0;
+      for (const decl of statement.declarationList.declarations) {
+        if (!ts.isIdentifier(decl.name)) continue;
+        const symbol = this.symbolOf(decl.name);
+        const binding = symbol === null ? void 0 : this.bindings.get(symbol);
+        if (symbol === null || binding === void 0 || DROPPED_KINDS.has(binding.kind)) continue;
+        if (constant && decl.initializer !== void 0 && PRIMITIVE_KINDS.has(binding.kind) && this.isModuleConstant(decl.initializer)) {
+          this.moduleConstants.add(symbol);
+          continue;
+        }
+        this.claimMember(symbol, decl.name.text, this.fields);
+      }
+    }
+    const visit = (node) => {
+      if ((ts.isVariableDeclaration(node) || ts.isParameter(node) || ts.isFunctionDeclaration(node)) && node.name !== void 0 && ts.isIdentifier(node.name) && SCENE_LOCALS.has(node.name.text)) {
+        this.residue(node, "unconverted", "scene", `name ${node.name.text}`, `The ported scene keeps the game API in locals named game and port; rename this ${node.name.text}.`);
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(this.sf);
+  }
+  claimMember(symbol, name, into) {
+    into.add(symbol);
+    this.memberNames.set(symbol, RESERVED_MEMBERS.has(name) ? `${name}${MEMBER_SUFFIX}` : name);
+  }
+  memberRef(symbol, fallback) {
+    const name = this.memberNames.get(symbol);
+    return name === void 0 ? fallback : `this.${name}`;
+  }
+  isModuleConstant(init) {
+    let constant = true;
+    const visit = (node) => {
+      if (!constant) return;
+      if (ts.isCallExpression(node) || ts.isNewExpression(node) || ts.isArrayLiteralExpression(node) || ts.isObjectLiteralExpression(node) || ts.isFunctionLike(node)) {
+        const mathCall = ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "Math" && node.expression.name.text !== "random";
+        if (!mathCall) constant = false;
+      }
+      if (ts.isIdentifier(node) && !(ts.isPropertyAccessExpression(node.parent) && node.parent.name === node)) {
+        const symbol = this.symbolOf(node);
+        if (node.text !== "Math" && (symbol === null || !this.moduleConstants.has(symbol))) constant = false;
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(init);
+    return constant;
+  }
+  emitScene() {
+    this.classify();
+    const constants = [];
+    const fields = [];
+    const methods = [];
+    const setup = [];
+    for (const statement of this.sf.statements) {
+      if (ts.isImportDeclaration(statement)) {
+        if (ts.isStringLiteral(statement.moduleSpecifier) && importsThree(`from "${statement.moduleSpecifier.text}"`)) this.count("scene");
+        else this.residue(statement, "unconverted", "dom", "import", "Only @cimplify/sdk entry points and relative imports are allowed; bring this module into src/ or replace it.");
+        continue;
+      }
+      if (ts.isFunctionDeclaration(statement)) {
+        methods.push(this.emitMethod(statement));
+        continue;
+      }
+      if (ts.isVariableStatement(statement)) {
+        this.emitTopLevelVariables(statement, constants, fields, setup);
+        continue;
+      }
+      if (this.isLoopStart(statement)) {
+        this.count("loop");
+        continue;
+      }
+      this.setupDepth++;
+      const emitted = this.emit(statement);
+      this.setupDepth--;
+      if (emitted !== DROP) setup.push(emitted);
+    }
+    for (const [id, name] of this.hudSlots) {
+      this.gameTypeImports.add("HudSlot");
+      fields.push(`private ${name}!: HudSlot;`);
+      setup.unshift(`this.${name} = game.ui.hudText(${JSON.stringify(id)});`);
+      this.count("dom");
+    }
+    return this.assemble(constants, fields, methods, [...setup, ...this.setupTail()]);
+  }
+  isLoopStart(statement) {
+    if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression)) return false;
+    const callee = statement.expression.expression;
+    if (this.loopFunction === null) return false;
+    if (ts.isIdentifier(callee)) return this.symbolOf(callee) === this.loopFunction;
+    return ts.isPropertyAccessExpression(callee) && callee.name.text === "setAnimationLoop";
+  }
+  setupTail() {
+    const tail = [];
+    const env = [];
+    if (this.env.background !== null) env.push(`background: { color: ${this.env.background} }`);
+    if (this.env.fog !== null) env.push(`fog: ${this.env.fog}`);
+    if (this.env.shadows !== null) env.push(`shadows: ${this.env.shadows}`);
+    if (this.env.toneMapping !== null) env.push(`toneMapping: ${this.env.toneMapping}`);
+    if (this.env.exposure !== null) env.push(`exposure: ${this.env.exposure}`);
+    if (env.length > 0) tail.push(`game.graphics.setEnvironment({ ${env.join(", ")} });`);
+    for (const statement of this.sf.statements) {
+      if (!ts.isVariableStatement(statement)) continue;
+      for (const decl of statement.declarationList.declarations) {
+        if (!ts.isIdentifier(decl.name)) continue;
+        const symbol = this.symbolOf(decl.name);
+        const binding = symbol === null ? void 0 : this.bindings.get(symbol);
+        if (symbol === null || binding === void 0 || binding.light !== "directional" && binding.light !== "spot") continue;
+        const target = binding.target ?? ["0", "0", "0"];
+        tail.push(`port.lookAt(${this.memberRef(symbol, binding.name)}, ${target.join(", ")});`);
+      }
+    }
+    if (this.keyCodes.size > 0) tail.push(`port.keys([${[...this.keyCodes].sort().map((c) => JSON.stringify(c)).join(", ")}]);`);
+    return tail;
+  }
+  assemble(constants, fields, methods, setup) {
+    const gameValues = [...this.gameImports].sort();
+    const gameTypes = [...this.gameTypeImports, "Game", "GameScene"].filter((v, i, a) => a.indexOf(v) === i).sort();
+    const kitValues = [...this.kitImports].sort();
+    const kitTypes = [...this.kitTypeImports].sort();
+    const byName = (a, b) => a.replace("type ", "").localeCompare(b.replace("type ", ""));
+    const gameSpecifiers = [...gameTypes.map((t) => `type ${t}`), ...gameValues].sort(byName);
+    const kitSpecifiers = [...kitTypes.map((t) => `type ${t}`), ...kitValues].sort(byName);
+    const loop = this.loopFunction;
+    const loopCall = loop === null ? null : `${this.memberRef(loop, loop.name)}(${this.loopHasTime ? "this.port.elapsedSeconds() * 1000" : ""});`;
+    const body = [];
+    body.push(`import { ${gameSpecifiers.join(", ")} } from "@cimplify/sdk/game";`);
+    body.push(`import { ${kitSpecifiers.join(", ")} } from "@cimplify/sdk/game/kit";`);
+    body.push("");
+    for (const line of constants) body.push(this.indent(line, 0));
+    if (constants.length > 0) body.push("");
+    body.push(`export class ${sceneClassName(this.options.sceneName)} implements GameScene<Game> {`);
+    body.push(`${INDENT}readonly name = ${JSON.stringify(this.options.sceneName)};`);
+    body.push(`${INDENT}private game!: Game;`);
+    body.push(`${INDENT}private port!: ThreePort;`);
+    body.push(`${INDENT}private readonly assets: PortAssetReader | null;`);
+    for (const line of fields) body.push(this.indent(line, 1));
+    body.push("");
+    body.push(`${INDENT}constructor(assets: PortAssetReader | null = null) {`);
+    body.push(`${INDENT.repeat(2)}this.assets = assets;`);
+    body.push(`${INDENT}}`);
+    body.push("");
+    body.push(`${INDENT}enter(game: Game): void {`);
+    body.push(`${INDENT.repeat(2)}this.game = game;`);
+    body.push(`${INDENT.repeat(2)}const port = new ThreePort(game, this.assets);`);
+    body.push(`${INDENT.repeat(2)}this.port = port;`);
+    for (const statement of setup) body.push(this.indent(statement, 2));
+    body.push(`${INDENT}}`);
+    body.push("");
+    body.push(`${INDENT}fixedUpdate(): void {`);
+    body.push(`${INDENT.repeat(2)}this.port.dispatchInput();`);
+    if (loopCall !== null) body.push(`${INDENT.repeat(2)}${loopCall}`);
+    body.push(`${INDENT}}`);
+    for (const method of methods) {
+      body.push("");
+      body.push(this.indent(method, 1));
+    }
+    body.push("}");
+    return `${body.join("\n").replace(BLANK_RUNS, "\n\n")}
+`;
+  }
+  indent(block, depth) {
+    const lines2 = block.split("\n");
+    const base = lines2.slice(1).reduce((min, line) => {
+      if (line.trim().length === 0) return min;
+      const lead = line.length - line.trimStart().length;
+      return Math.min(min, lead);
+    }, Number.POSITIVE_INFINITY);
+    const strip = Number.isFinite(base) ? base : 0;
+    const prefix = INDENT.repeat(depth);
+    const closing = lines2.length > 1 ? lines2[lines2.length - 1] : "";
+    const closingLead = closing.length - closing.trimStart().length;
+    const shift = Math.min(strip, closingLead);
+    return lines2.map((line, i) => {
+      if (line.trim().length === 0) return "";
+      if (i === 0) return prefix + line.trimStart();
+      return prefix + line.slice(Math.min(shift, line.length - line.trimStart().length));
+    }).join("\n");
+  }
+  emitTopLevelVariables(statement, constants, fields, setup) {
+    const constant = (statement.declarationList.flags & ts.NodeFlags.Const) !== 0;
+    for (const decl of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(decl.name)) {
+        this.residue(decl, "unconverted", "scene", "destructuring declaration", "Declare each value on its own line so the converter can place it.");
+        fields.push(`private ${decl.getText(this.sf)};`);
+        continue;
+      }
+      const symbol = this.symbolOf(decl.name);
+      const binding = symbol === null ? null : this.bindings.get(symbol) ?? null;
+      const kind = binding?.kind ?? "unknown";
+      if (DROPPED_KINDS.has(kind)) {
+        this.count(kind === "clock" ? "loop" : kind === "scene" ? "scene" : kind === "renderer" ? "renderer" : "loader");
+        continue;
+      }
+      const init = decl.initializer;
+      if (symbol !== null && this.moduleConstants.has(symbol) && init !== void 0) {
+        constants.push(`const ${decl.name.text} = ${this.emit(init)};`);
+        continue;
+      }
+      if (binding !== null) this.foldSiblings(decl, binding);
+      const member = symbol === null ? decl.name.text : this.memberNames.get(symbol) ?? decl.name.text;
+      const hudId = init !== void 0 && ts.isCallExpression(init) ? this.hudIdOf(init) : null;
+      if (hudId !== null) {
+        this.gameTypeImports.add("HudSlot");
+        fields.push(`private ${member}!: HudSlot;`);
+        setup.push(`this.${member} = game.ui.hudText(${JSON.stringify(hudId)});`);
+        this.count("dom");
+        continue;
+      }
+      const type = this.typeOf(kind, binding);
+      if (init !== void 0 && this.isPure(init)) {
+        const annotation = type !== null && this.needsAnnotation(init) ? `: ${type}` : "";
+        fields.push(`private ${constant ? "readonly " : ""}${member}${annotation} = ${this.emit(init)};`);
+        continue;
+      }
+      if (type === null) {
+        const from = init === void 0 ? "" : ` from ${init.getText(this.sf).slice(0, 80)}`;
+        this.residue(decl, "unconverted", "scene", "untyped declaration", `Give ${decl.name.text} a type; the converter could not infer one${from}.`);
+      }
+      fields.push(`private ${member}!: ${type ?? "unknown"};`);
+      if (init === void 0) continue;
+      this.setupDepth++;
+      setup.push(`this.${member} = ${this.emit(init)};`);
+      this.setupDepth--;
+    }
+  }
+  needsAnnotation(init) {
+    return ts.isArrayLiteralExpression(init) && init.elements.length === 0 || ts.isObjectLiteralExpression(init) && init.properties.length === 0 || init.kind === ts.SyntaxKind.NullKeyword;
+  }
+  isPure(expr) {
+    let pure = true;
+    const visit = (node) => {
+      if (!pure) return;
+      if (ts.isIdentifier(node)) {
+        if (this.isThreeRoot(node)) pure = false;
+        if (node.text === "document" || node.text === "window" || node.text === "performance") pure = false;
+        const symbol = this.symbolOf(node);
+        if (symbol !== null && this.functions.has(symbol)) pure = false;
+        const binding = symbol === null ? void 0 : this.bindings.get(symbol);
+        if (binding !== void 0 && !this.isPureBinding(binding)) pure = false;
+      }
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "Math" && node.expression.name.text === "random") pure = false;
+      ts.forEachChild(node, visit);
+    };
+    visit(expr);
+    return pure;
+  }
+  isPureBinding(binding) {
+    const decl = this.declarationOf(binding.symbol);
+    if (decl === null || !ts.isVariableDeclaration(decl)) return true;
+    if (decl.parent.parent.parent !== this.sf) return true;
+    return decl.initializer === void 0 || this.isPure(decl.initializer);
+  }
+  foldSiblings(decl, binding) {
+    const statement = decl.parent.parent;
+    const container = statement.parent;
+    if (!ts.isBlock(container) && !ts.isSourceFile(container)) return;
+    for (const sibling of container.statements) {
+      if (!ts.isExpressionStatement(sibling) || !ts.isBinaryExpression(sibling.expression)) continue;
+      const assign = sibling.expression;
+      if (assign.operatorToken.kind !== ts.SyntaxKind.EqualsToken) continue;
+      const path2 = this.pathOf(assign.left);
+      if (path2 === null || path2.root.getText(this.sf) !== binding.name) continue;
+      const value = assign.right.getText(this.sf);
+      const [first, second, third] = path2.names;
+      if (path2.names.length === 1 && (first === "castShadow" || first === "receiveShadow")) {
+        if (value === "true") binding.shadows |= first === "castShadow" ? CAST_SHADOW_FLAG : RECEIVE_SHADOW_FLAG;
+        this.foldedStatements.add(sibling);
+      }
+      if (first === "shadow" && second === "mapSize" && (third === "width" || third === "height")) {
+        binding.shadowMapSize = value;
+        this.foldedStatements.add(sibling);
+      }
+    }
+  }
+  pathOf(expr) {
+    const names = [];
+    let current = expr;
+    while (ts.isPropertyAccessExpression(current)) {
+      names.unshift(current.name.text);
+      current = current.expression;
+    }
+    return names.length === 0 ? null : { root: current, names };
+  }
+  emitMethod(fn) {
+    for (const param of fn.parameters) {
+      if (param.type !== void 0 || !ts.isIdentifier(param.name)) continue;
+      const symbol2 = this.symbolOf(param.name);
+      const binding = symbol2 === null ? null : this.bindings.get(symbol2) ?? null;
+      if (binding === null || this.typeOf(binding.kind, binding) === null) {
+        this.residue(param, "unconverted", "scene", "untyped parameter", `Give parameter ${param.name.text} of ${fn.name?.text ?? "this function"} a type; no call site told the converter what it receives.`);
+      }
+    }
+    const symbol = fn.name === void 0 ? null : this.symbolOf(fn.name);
+    if (symbol !== null && symbol === this.loopFunction) this.count("loop");
+    if (fn.body !== void 0 && this.loopReachable.has(fn)) this.adviseAllocations(fn.body);
+    const name = symbol === null ? fn.name?.text ?? "anonymous" : this.memberNames.get(symbol) ?? fn.name?.text ?? "anonymous";
+    const isAsync = fn.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
+    const params = fn.parameters.map((p) => this.emit(p)).join(", ");
+    const returns = fn.type === void 0 ? "" : `: ${fn.type.getText(this.sf)}`;
+    const body = fn.body === void 0 ? "{}" : this.withSceneLocals(this.emit(fn.body), this.statementIndent(fn) + INDENT);
+    return `private ${isAsync ? "async " : ""}${name}(${params})${returns} ${body}`;
+  }
+  withSceneLocals(body, indent) {
+    const locals = [];
+    if (/\bgame\./.test(body)) locals.push("const game = this.game;");
+    if (/\bport\./.test(body)) locals.push("const port = this.port;");
+    if (locals.length === 0 || !body.startsWith("{")) return body;
+    return `{
+${locals.map((l) => indent + l).join("\n")}${body.slice(1)}`;
+  }
+  emit(node) {
+    const rewritten = this.rewrite(node);
+    if (rewritten !== null) return rewritten;
+    return this.spliced(node);
+  }
+  spliced(node) {
+    const start = node.getStart(this.sf);
+    let out = "";
+    let cursor = start;
+    const parts = [];
+    ts.forEachChild(node, (child) => {
+      parts.push(child);
+    });
+    for (const child of parts) {
+      const childStart = child.getStart(this.sf);
+      if (childStart < cursor) continue;
+      out += this.text.slice(cursor, childStart);
+      const emitted = this.emit(child);
+      if (emitted === DROP && ts.isStatement(child) && !ts.isBlock(node) && !ts.isSourceFile(node) && !ts.isCaseOrDefaultClause(node)) {
+        out += "{}";
+        cursor = child.end;
+        continue;
+      }
+      if (emitted === DROP && ts.isStatement(child)) {
+        out = out.replace(/[ \t]*$/, "");
+        if (out.endsWith("\n")) out = out.slice(0, -1);
+        cursor = child.end;
+        continue;
+      }
+      out += emitted === DROP ? "" : emitted;
+      cursor = child.end;
+    }
+    out += this.text.slice(cursor, node.end);
+    return out;
+  }
+  rewrite(node) {
+    if (this.foldedStatements.has(node)) {
+      this.count("object");
+      return DROP;
+    }
+    if (ts.isFunctionLike(node) && !ts.isFunctionDeclaration(node) && (ts.isArrowFunction(node) || ts.isFunctionExpression(node))) return this.rewriteCallback(node);
+    if (ts.isFunctionDeclaration(node)) return this.rewriteFunction(node);
+    if (ts.isForOfStatement(node)) return this.rewriteForOf(node);
+    if (ts.isShorthandPropertyAssignment(node)) return this.rewriteShorthand(node);
+    if (ts.isParameter(node)) return this.rewriteParameter(node);
+    if (ts.isVariableStatement(node)) return this.rewriteLocalVariables(node);
+    if (ts.isExpressionStatement(node)) return this.rewriteExpressionStatement(node);
+    if (ts.isNewExpression(node)) return this.rewriteNew(node);
+    if (ts.isCallExpression(node)) return this.rewriteCall(node);
+    if (ts.isBinaryExpression(node)) return this.rewriteBinary(node);
+    if (ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) return this.rewriteIncrement(node);
+    if (ts.isPropertyAccessExpression(node)) return this.rewriteProperty(node);
+    if (ts.isElementAccessExpression(node)) return null;
+    if (ts.isIdentifier(node)) return this.rewriteIdentifier(node);
+    return null;
+  }
+  rewriteIdentifier(node) {
+    const member = this.memberReference(node);
+    if (member !== null) return member;
+    if (!this.isThreeRoot(node)) return null;
+    const line = this.sf.getLineAndCharacterOfPosition(node.getStart(this.sf)).line + 1;
+    if (this.residueItems.some((r) => r.line === line && r.kind === "unconverted")) return null;
+    this.residue(node, "unconverted", "scene", node.text, "This Three.js API has no automatic mapping; see the porting-threejs guide topic for the game API equivalent.");
+    return null;
+  }
+  memberReference(node) {
+    const parent = node.parent;
+    if ((ts.isVariableDeclaration(parent) || ts.isParameter(parent) || ts.isFunctionDeclaration(parent) || ts.isPropertyAssignment(parent) || ts.isPropertyAccessExpression(parent) || ts.isShorthandPropertyAssignment(parent)) && parent.name === node) return null;
+    const symbol = this.symbolOf(node);
+    if (symbol === null) return null;
+    const name = this.memberNames.get(symbol);
+    if (name === void 0) return null;
+    if (this.methods.has(symbol) && !(ts.isCallExpression(parent) && parent.expression === node)) return `this.${name}.bind(this)`;
+    return `this.${name}`;
+  }
+  rewriteShorthand(node) {
+    const symbol = this.checker.getShorthandAssignmentValueSymbol(node) ?? null;
+    if (symbol === null || !this.memberNames.has(symbol)) return null;
+    return `${node.name.text}: ${this.memberRef(symbol, node.name.text)}`;
+  }
+  rewriteFunction(fn) {
+    if (fn.body === void 0 || fn.name === void 0 || fn.parent === this.sf) return null;
+    if (this.loopReachable.has(fn)) this.adviseAllocations(fn.body);
+    if (this.usesOwnThis(fn)) return null;
+    const isAsync = fn.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
+    return `const ${fn.name.text} = ${isAsync ? "async " : ""}(${fn.parameters.map((p) => this.emit(p)).join(", ")}) => ${this.emit(fn.body)};`;
+  }
+  usesOwnThis(fn) {
+    let uses = false;
+    const visit = (node) => {
+      if (uses) return;
+      if (node.kind === ts.SyntaxKind.ThisKeyword || ts.isIdentifier(node) && node.text === "arguments") uses = true;
+      if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isClassLike(node)) return;
+      ts.forEachChild(node, visit);
+    };
+    if (fn.body !== void 0) ts.forEachChild(fn.body, visit);
+    return uses || fn.asteriskToken !== void 0;
+  }
+  rewriteForOf(node) {
+    if (node.awaitModifier !== void 0 || !ts.isVariableDeclarationList(node.initializer)) return null;
+    const decl = node.initializer.declarations[0];
+    if (decl === void 0 || !ts.isIdentifier(decl.name) || !isArrayKind(this.kindOf(node.expression))) return null;
+    const source = this.emit(node.expression);
+    if (!SIMPLE_REFERENCE.test(source)) return null;
+    const item = decl.name.text;
+    let index = `${item}Index`;
+    for (let n = 2; this.text.includes(index); n++) index = `${item}Index${n}`;
+    const read = `const ${item} = ${source}[${index}];`;
+    const body = this.emit(node.statement);
+    const head = `for (let ${index} = 0; ${index} < ${source}.length; ${index}++)`;
+    this.count("loop");
+    if (ts.isBlock(node.statement) && body.startsWith("{")) {
+      const first = node.statement.statements[0];
+      const indent = first === void 0 ? this.statementIndent(node) + INDENT : this.statementIndent(first);
+      return `${head} {
+${indent}${read}${body.slice(1)}`;
+    }
+    return `${head} {
+${this.statementIndent(node)}${INDENT}${read}
+${this.statementIndent(node)}${INDENT}${body}
+${this.statementIndent(node)}}`;
+  }
+  rewriteCallback(fn) {
+    const param = fn.parameters[0];
+    const symbol = param !== void 0 && ts.isIdentifier(param.name) ? this.symbolOf(param.name) : null;
+    const binding = symbol === null ? void 0 : this.bindings.get(symbol);
+    const gltf = param !== void 0 && ts.isIdentifier(param.name) && binding?.kind === "gltf" && ts.isBlock(fn.body) && this.usesScene(fn.body, symbol);
+    const asArrow = ts.isArrowFunction(fn) || !this.usesOwnThis(fn);
+    if (!gltf && !asArrow) return null;
+    let body = this.emit(fn.body);
+    if (gltf && param !== void 0 && ts.isIdentifier(param.name) && body.startsWith("{")) {
+      const first = ts.isBlock(fn.body) ? fn.body.statements[0] : void 0;
+      const indent = first === void 0 ? this.statementIndent(fn) + INDENT : this.statementIndent(first);
+      body = `{
+${indent}const ${param.name.text}Scene = port.instantiate(${param.name.text});${body.slice(1)}`;
+    }
+    const isAsync = fn.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
+    const params = fn.parameters.map((p) => this.emit(p)).join(", ");
+    const returns = fn.type === void 0 ? "" : `: ${fn.type.getText(this.sf)}`;
+    return `${isAsync ? "async " : ""}(${params})${returns} => ${body}`;
+  }
+  usesScene(body, symbol) {
+    let used = false;
+    const visit = (node) => {
+      if (ts.isPropertyAccessExpression(node) && node.name.text === "scene" && ts.isIdentifier(node.expression) && this.symbolOf(node.expression) === symbol) used = true;
+      ts.forEachChild(node, visit);
+    };
+    visit(body);
+    return used;
+  }
+  adviseAllocations(body) {
+    const visit = (node) => {
+      if (ts.isFunctionDeclaration(node)) return;
+      if (ts.isNewExpression(node)) {
+        const name = this.threeName(node.expression);
+        if (name !== "Color") this.residue(node, "advisory", "loop", "allocation in the frame loop", "Create this once outside the loop (a closure-level scratch) and reuse it every frame.");
+      }
+      if (ts.isArrayLiteralExpression(node) || ts.isObjectLiteralExpression(node) && !ts.isCallExpression(node.parent)) {
+        this.residue(node, "advisory", "loop", "allocation in the frame loop", "Array and object literals allocate every frame; hoist them into closure-level scratch.");
+      }
+      if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        this.residue(node, "advisory", "loop", "closure in the frame loop", "A closure created per frame allocates; hoist it to a named function.");
+        return;
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(body);
+  }
+  rewriteParameter(param) {
+    if (param.type !== void 0 || !ts.isIdentifier(param.name)) return null;
+    const symbol = this.symbolOf(param.name);
+    const binding = symbol === null ? null : this.bindings.get(symbol) ?? null;
+    if (binding === null) return null;
+    const type = this.typeOf(binding.kind, binding);
+    if (type === null) return null;
+    const initializer = param.initializer === void 0 ? "" : ` = ${this.emit(param.initializer)}`;
+    return `${param.dotDotDotToken === void 0 ? "" : "..."}${param.name.text}: ${type}${initializer}`;
+  }
+  rewriteLocalVariables(statement) {
+    const parts = [];
+    for (const decl of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(decl.name)) {
+        parts.push(this.emit(decl));
+        continue;
+      }
+      const symbol = this.symbolOf(decl.name);
+      const binding = symbol === null ? null : this.bindings.get(symbol) ?? null;
+      const kind = binding?.kind ?? "unknown";
+      if (kind === "clock" || kind === "gltfLoader" || kind === "textureLoader" || kind === "scene" || kind === "renderer") {
+        this.count(kind === "clock" ? "loop" : "loader");
+        continue;
+      }
+      if (binding !== null) this.foldSiblings(decl, binding);
+      const type = this.typeOf(kind, binding);
+      const annotate = decl.type === void 0 && type !== null && (decl.initializer === void 0 || this.needsAnnotation(decl.initializer));
+      const init = decl.initializer === void 0 ? "" : ` = ${this.emit(decl.initializer)}`;
+      parts.push(`${decl.name.text}${annotate ? `: ${type}` : decl.type === void 0 ? "" : `: ${decl.type.getText(this.sf)}`}${init}`);
+    }
+    if (parts.length === 0) return DROP;
+    const flags = statement.declarationList.flags;
+    const keyword = (flags & ts.NodeFlags.Const) !== 0 ? "const" : (flags & ts.NodeFlags.Let) !== 0 ? "let" : "var";
+    return `${keyword} ${parts.join(", ")};`;
+  }
+  statementIndent(node) {
+    const start = node.getStart(this.sf);
+    const lineStart = this.text.lastIndexOf("\n", start - 1) + 1;
+    return this.text.slice(lineStart, start).replace(/\S/g, " ");
+  }
+  rewriteExpressionStatement(statement) {
+    const expr = statement.expression;
+    if (ts.isCallExpression(expr)) {
+      const many = this.rewriteMultiCall(expr);
+      if (many !== null) return many.length === 0 ? DROP : many.map((line) => `${line};`).join(`
+${this.statementIndent(statement)}`);
+      if (this.isDroppedCall(expr)) return DROP;
+    }
+    if (ts.isBinaryExpression(expr) && expr.operatorToken.kind === ts.SyntaxKind.EqualsToken && this.isDroppedAssignment(expr)) return DROP;
+    return null;
+  }
+  rewriteMultiCall(expr) {
+    const callee = expr.expression;
+    if (!ts.isPropertyAccessExpression(callee)) return null;
+    const method = callee.name.text;
+    const receiverKind = this.kindOf(callee.expression);
+    if (receiverKind === "scene" && (method === "add" || method === "remove")) {
+      this.count("scene");
+      if (method === "add" && this.setupDepth > 0) return [];
+      return expr.arguments.filter((a) => !this.isLightTarget(a) && !(method === "add" && this.createdVisible(a))).map((a) => `port.setVisible(${this.emitEntity(a)}, ${method === "add" ? "true" : "false"})`);
+    }
+    if (receiverKind === "entity" && (method === "add" || method === "remove")) {
+      this.count("object");
+      return expr.arguments.map((a) => `port.${method}(${this.emit(callee.expression)}, ${this.emitEntity(a)})`);
+    }
+    return null;
+  }
+  createdVisible(expr) {
+    if (!ts.isIdentifier(expr)) return false;
+    const symbol = this.symbolOf(expr);
+    const decl = symbol === null ? null : this.declarationOf(symbol);
+    if (decl === null || !ts.isVariableDeclaration(decl) || decl.initializer === void 0 || !ts.isNewExpression(decl.initializer)) return false;
+    const name = this.threeName(decl.initializer.expression);
+    return name !== null && ENTITY_CLASSES.has(name) && decl.parent.parent.parent !== this.sf;
+  }
+  isLightTarget(expr) {
+    return ts.isPropertyAccessExpression(expr) && expr.name.text === "target";
+  }
+  emitEntity(expr) {
+    if (ts.isCallExpression(expr) && ts.isPropertyAccessExpression(expr.expression) && expr.expression.name.text === "getObject" && this.kindOf(expr.expression.expression) === "controls") {
+      const binding = this.bindingOf(expr.expression.expression);
+      if (binding?.camera) return this.emit(binding.camera);
+    }
+    return this.emit(expr);
+  }
+  isDroppedCall(expr) {
+    const callee = expr.expression;
+    if (ts.isIdentifier(callee) && callee.text === "requestAnimationFrame") {
+      this.count("loop");
+      return true;
+    }
+    if (!ts.isPropertyAccessExpression(callee)) return false;
+    const method = callee.name.text;
+    const receiver = callee.expression;
+    const receiverKind = this.kindOf(receiver);
+    if (method === "requestAnimationFrame") {
+      this.count("loop");
+      return true;
+    }
+    if (receiverKind === "renderer") return this.dropRendererCall(expr, method);
+    if (method === "appendChild" && expr.arguments[0] !== void 0 && this.kindOf(expr.arguments[0]) === "domElement") {
+      this.count("renderer");
+      return true;
+    }
+    if ((receiverKind === "geometry" || receiverKind === "material" || receiverKind === "texture") && method === "dispose") {
+      this.count(receiverKind === "geometry" ? "geometry" : "material");
+      return true;
+    }
+    if (receiverKind === "clock" && (method === "start" || method === "stop")) {
+      this.count("loop");
+      return true;
+    }
+    if (receiverKind === "mixer" && method === "update") {
+      this.count("animation");
+      return true;
+    }
+    if (receiverKind === "entity" && (CAMERA_DROPPED_MEMBERS.has(method) || MATRIX_UPDATES.has(method))) {
+      this.count("camera");
+      return true;
+    }
+    if (method === "addEventListener") {
+      const type = expr.arguments[0];
+      if (type !== void 0 && ts.isStringLiteralLike(type) && DROPPED_EVENTS.has(type.text) && this.isListenerTarget(receiver)) {
+        this.count("renderer");
+        return true;
+      }
+    }
+    const path2 = this.pathOf(callee);
+    if (path2 !== null && path2.names.length === 3 && path2.names[0] === "target" && path2.names[1] === "position" && method === "set" && this.kindOf(path2.root) === "entity") {
+      const light = this.bindingOf(path2.root);
+      if (light !== null && expr.arguments.length === 3) {
+        light.target = [this.emit(expr.arguments[0]), this.emit(expr.arguments[1]), this.emit(expr.arguments[2])];
+        this.count("light");
+        return true;
+      }
+    }
+    return false;
+  }
+  dropRendererCall(expr, method) {
+    if (method === "setClearColor" && expr.arguments[0] !== void 0) {
+      const color = this.colorExpr(expr.arguments[0]);
+      if (color !== null) return this.applyEnvironment("background", color, expr);
+    }
+    this.count("renderer");
+    return true;
+  }
+  isListenerTarget(expr) {
+    if (ts.isIdentifier(expr) && LISTENER_TARGETS.has(expr.text)) return true;
+    if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression) && expr.expression.text === "document" && expr.name.text === "body") return true;
+    return this.kindOf(expr) === "domElement";
+  }
+  applyEnvironment(key, value, at) {
+    if (this.setupDepth > 0) {
+      this.count("scene");
+      this.env[key] = value;
+      return true;
+    }
+    this.residue(at, "unconverted", "scene", "environment change at run time", `Call game.graphics.setEnvironment with the full environment here; the converter only folds setup-time ${key}.`);
+    return false;
+  }
+  isDroppedAssignment(expr) {
+    const path2 = this.pathOf(expr.left);
+    if (path2 === null) return false;
+    const rootKind = this.kindOf(path2.root);
+    const [first, second] = path2.names;
+    if (rootKind === "scene" && path2.names.length === 1) {
+      if (first === "background") {
+        const color = this.colorExpr(expr.right);
+        if (color === null) {
+          this.residue(expr, "unconverted", "scene", "scene.background", "Only colors convert; use setEnvironment({ background: { texture } }) or { sky: true } for textures and skies.");
+          return false;
+        }
+        return this.applyEnvironment("background", color, expr);
+      }
+      if (first === "fog") {
+        const fog = this.fogExpr(expr.right);
+        if (fog === null) {
+          this.residue(expr, "unconverted", "scene", "scene.fog", "Use setEnvironment({ fog: { mode, color, near, far | density } }).");
+          return false;
+        }
+        return this.applyEnvironment("fog", fog, expr);
+      }
+    }
+    if (rootKind === "renderer") {
+      if (first === "shadowMap" && second === "enabled") return this.applyEnvironment("shadows", this.emit(expr.right), expr);
+      if (first === "toneMapping") {
+        const constant = this.threeName(expr.right);
+        const mapped = constant === null ? void 0 : TONE_MAPPINGS[constant];
+        if (mapped !== void 0) return this.applyEnvironment("toneMapping", JSON.stringify(mapped), expr);
+      }
+      if (first === "toneMappingExposure") return this.applyEnvironment("exposure", this.emit(expr.right), expr);
+      this.count("renderer");
+      return true;
+    }
+    if (rootKind === "entity" && path2.names.length === 1 && CAMERA_DROPPED_MEMBERS.has(first)) {
+      this.count("camera");
+      return true;
+    }
+    if (rootKind === "entity" && first === "shadow") {
+      this.count("light");
+      return true;
+    }
+    if (rootKind === "action" && first === "clampWhenFinished") {
+      this.residue(expr, "advisory", "animation", "clampWhenFinished", "Engine clips stop on their last pose with setLoop(false); check the end pose in the preview.");
+      return true;
+    }
+    return false;
+  }
+  fogExpr(expr) {
+    if (!ts.isNewExpression(expr)) return null;
+    const name = this.threeName(expr.expression);
+    const args = expr.arguments ?? [];
+    const color = args[0] === void 0 ? null : this.colorExpr(args[0]);
+    if (color === null) return null;
+    if (name === "Fog") return `{ mode: "linear", color: ${color}, near: ${args[1] === void 0 ? "1" : this.emit(args[1])}, far: ${args[2] === void 0 ? "1000" : this.emit(args[2])} }`;
+    if (name === "FogExp2") return `{ mode: "exp2", color: ${color}, density: ${args[1] === void 0 ? "0.00025" : this.emit(args[1])} }`;
+    return null;
+  }
+  colorExpr(expr) {
+    if (ts.isNumericLiteral(expr)) return expr.getText(this.sf);
+    if (ts.isStringLiteralLike(expr)) {
+      const value = colorLiteral(expr.text);
+      return value === null ? null : hexText(value);
+    }
+    if (ts.isNewExpression(expr) && this.threeName(expr.expression) === "Color") {
+      const args = expr.arguments ?? [];
+      if (args.length === 1) return this.colorExpr(args[0]);
+      if (args.length === 3 && args.every((a) => ts.isNumericLiteral(a))) {
+        const [r, g, b] = args.map((a) => Math.round(Number(a.text) * COLOR_CHANNEL_MAX));
+        return hexText(r << 16 | g << 8 | b);
+      }
+      return null;
+    }
+    const kind = this.kindOf(expr);
+    if (kind === "number" || ts.isIdentifier(expr) || ts.isPropertyAccessExpression(expr)) return this.emit(expr);
+    return null;
+  }
+  rewriteNew(expr) {
+    const name = this.threeName(expr.expression);
+    if (name === null) return null;
+    const args = expr.arguments ?? [];
+    const geometry = THREE_GEOMETRIES[name];
+    if (geometry !== void 0) return this.newGeometry(expr, name, args);
+    const material = THREE_MATERIALS[name];
+    if (material !== void 0) return this.newMaterial(expr, name, args);
+    const light = THREE_LIGHTS[name];
+    if (light !== void 0) return this.newLight(expr, args);
+    const controls = THREE_CONTROLS[name];
+    if (controls !== void 0) {
+      this.kitImports.add(controls);
+      this.count("controls");
+      this.touchHandled = true;
+      if (args[0] === void 0) this.gameImports.add("NO_ENTITY");
+      const camera = args[0] === void 0 ? "NO_ENTITY" : this.emit(args[0]);
+      return `new ${controls}(game.transforms, ${camera}, game.input)`;
+    }
+    switch (name) {
+      case "Mesh":
+        return this.newMesh(expr, args);
+      case "Group":
+        this.count("object");
+        return "port.group()";
+      case "Object3D":
+        this.count("object");
+        return "port.object()";
+      case "PerspectiveCamera":
+        this.count("camera");
+        return `port.perspectiveCamera(${args[0] === void 0 ? DEFAULT_FOV : this.emit(args[0])}, ${args[2] === void 0 ? DEFAULT_NEAR : this.emit(args[2])}, ${args[3] === void 0 ? DEFAULT_FAR : this.emit(args[3])})`;
+      case "OrthographicCamera": {
+        this.count("camera");
+        const values = [0, 1, 2, 3].map((i) => args[i] === void 0 ? i % 2 === 0 ? "-1" : "1" : this.emit(args[i]));
+        return `port.orthographicCamera(${values.join(", ")}, ${args[4] === void 0 ? DEFAULT_NEAR : this.emit(args[4])}, ${args[5] === void 0 ? DEFAULT_FAR : this.emit(args[5])})`;
+      }
+      case "Vector3":
+        this.gameImports.add("Vec3");
+        this.count("math");
+        return `new Vec3(${args.map((a) => this.emit(a)).join(", ")})`;
+      case "Quaternion":
+        this.gameImports.add("Quat");
+        this.count("math");
+        return `new Quat(${args.map((a) => this.emit(a)).join(", ")})`;
+      case "Color": {
+        const color = this.colorExpr(expr);
+        if (color !== null) {
+          this.count("math");
+          return color;
+        }
+        this.residue(expr, "unconverted", "math", "Color", "Use a 0xrrggbb number.");
+        return null;
+      }
+      case "AnimationMixer":
+        this.count("animation");
+        if (args[0] === void 0) this.gameImports.add("NO_ENTITY");
+        return args[0] === void 0 ? "NO_ENTITY" : this.emit(args[0]);
+      case "Scene":
+      case "Clock":
+      case "GLTFLoader":
+      case "TextureLoader":
+      case "WebGLRenderer":
+        this.count("renderer");
+        return "undefined";
+      default:
+        this.residue(expr, "unconverted", this.areaOfClass(name), name, "No automatic mapping; see the porting-threejs guide topic for the game API equivalent.");
+        return null;
+    }
+  }
+  areaOfClass(name) {
+    if (name.endsWith("Geometry")) return "geometry";
+    if (name.endsWith("Material")) return "material";
+    if (name.endsWith("Light")) return "light";
+    if (name.endsWith("Loader")) return "loader";
+    if (name.endsWith("Camera")) return "camera";
+    if (name.startsWith("Audio") || name.endsWith("Audio")) return "audio";
+    if (name === "Raycaster") return "picking";
+    return "scene";
+  }
+  newGeometry(expr, name, args) {
+    const rule = THREE_GEOMETRIES[name];
+    const extended = args.length > rule.simpleArgs && rule.extendedFn !== null;
+    const fn = extended ? rule.extendedFn ?? rule.fn : rule.fn;
+    const values = args.map((a) => this.emit(a));
+    for (let i = values.length; i < rule.defaults.length; i++) values.push(String(rule.defaults[i]));
+    if (name === "PlaneGeometry" && !extended) values.length = Math.min(values.length, 2);
+    if (name === "BoxGeometry" && !extended) values.length = Math.min(values.length, 3);
+    this.gameImports.add(fn);
+    this.count("geometry");
+    if (expr.arguments === void 0) return `game.graphics.createGeometry(${fn}(${values.join(", ")}))`;
+    return `game.graphics.createGeometry(${fn}(${values.join(", ")}))`;
+  }
+  newMaterial(expr, name, args) {
+    const rule = THREE_MATERIALS[name];
+    const allowed = MATERIAL_PROPERTIES_BY_KIND[rule.kind];
+    const props = [`kind: "${rule.kind}"`];
+    const textures = [];
+    const desc = args[0];
+    let roughnessSet = false;
+    let shininess = null;
+    if (desc !== void 0 && !ts.isObjectLiteralExpression(desc)) {
+      this.residue(expr, "unconverted", "material", name, "Pass the material parameters as an object literal so they can be mapped.");
+      return null;
+    }
+    if (desc !== void 0) {
+      for (const prop of desc.properties) {
+        if (!ts.isPropertyAssignment(prop) && !ts.isShorthandPropertyAssignment(prop)) {
+          this.residue(prop, "unconverted", "material", `${name} spread`, "Write material parameters out one by one.");
+          continue;
+        }
+        const key = prop.name.getText(this.sf).replace(/^["']|["']$/g, "");
+        const value = ts.isPropertyAssignment(prop) ? prop.initializer : prop.name;
+        if (key === "shininess" && rule.shininessToRoughness) {
+          shininess = ts.isNumericLiteral(value) ? value.text : `(${this.emit(value)})`;
+          continue;
+        }
+        if (key === "specular" && rule.shininessToRoughness) continue;
+        if (!allowed.has(key)) {
+          this.residue(prop, "advisory", "material", `${name}.${key}`, `The ${rule.kind} material has no ${key}; it was dropped. Check the look in the preview.`);
+          continue;
+        }
+        if (key === "roughness") roughnessSet = true;
+        if (THREE_TEXTURE_SLOTS.includes(key)) {
+          if (this.kindOf(value) === "texture") {
+            textures.push([key, this.emit(value)]);
+            continue;
+          }
+        }
+        if (COLOR_PROPERTIES.has(key)) {
+          const color = this.colorExpr(value);
+          if (color === null) {
+            this.residue(prop, "unconverted", "material", `${name}.${key}`, "Use a 0xrrggbb number for colors.");
+            props.push(`${key}: ${this.emit(value)}`);
+          } else props.push(`${key}: ${color}`);
+          continue;
+        }
+        if (key === "side") {
+          const constant = this.threeName(value);
+          const side = constant === null ? void 0 : THREE_SIDES[constant];
+          if (side !== void 0) props.push(`side: "${side}"`);
+          else this.residue(prop, "unconverted", "material", `${name}.side`, 'Use side: "front" | "back" | "double".');
+          continue;
+        }
+        props.push(`${key}: ${this.emit(value)}`);
+      }
+    }
+    if (rule.shininessToRoughness && !roughnessSet) {
+      const s = shininess ?? String(PHONG_SHININESS_DEFAULT);
+      const literal = Number(s);
+      props.push(Number.isFinite(literal) ? `roughness: ${Number(Math.sqrt(SHININESS_OFFSET / (literal + SHININESS_OFFSET)).toFixed(ROUGHNESS_DIGITS))}` : `roughness: Math.sqrt(${SHININESS_OFFSET} / (${s} + ${SHININESS_OFFSET}))`);
+    }
+    if (rule.roughness !== null && !roughnessSet) props.push(`roughness: ${rule.roughness}`);
+    this.count("material");
+    let out = `game.graphics.createMaterial({ ${props.join(", ")} })`;
+    for (const [slot, texture] of textures) {
+      out = `port.withTexture(${out}, "${slot}", ${texture})`;
+      this.count("loader");
+    }
+    return out;
+  }
+  newLight(expr, args) {
+    const name = this.threeName(expr.expression) ?? "";
+    const rule = THREE_LIGHTS[name];
+    const options = [];
+    rule.params.forEach((param, i) => {
+      const arg = args[i];
+      if (arg === void 0) return;
+      if (param === "color" || param === "groundColor") {
+        const color = this.colorExpr(arg);
+        if (color === null) this.residue(arg, "unconverted", "light", `${name} ${param}`, "Use a 0xrrggbb number.");
+        options.push(`${param}: ${color ?? this.emit(arg)}`);
+        return;
+      }
+      options.push(`${param}: ${this.emit(arg)}`);
+    });
+    const owner = this.ownerBinding(expr);
+    if (owner !== null && (owner.shadows & CAST_SHADOW_FLAG) !== 0) options.push("castShadow: true");
+    if (owner?.shadowMapSize) options.push(`shadowMapSize: ${owner.shadowMapSize}`);
+    this.count("light");
+    return `port.light("${rule.light}"${options.length === 0 ? "" : `, { ${options.join(", ")} }`})`;
+  }
+  ownerBinding(expr) {
+    const parent = expr.parent;
+    if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+      const symbol = this.symbolOf(parent.name);
+      return symbol === null ? null : this.bindings.get(symbol) ?? null;
+    }
+    if (ts.isBinaryExpression(parent) && ts.isIdentifier(parent.left)) return this.bindingOf(parent.left);
+    return null;
+  }
+  newMesh(expr, args) {
+    const geometry = args[0];
+    const material = args[1];
+    if (geometry === void 0) {
+      this.residue(expr, "unconverted", "object", "Mesh without geometry", "Create the geometry first and pass it to the mesh.");
+      return null;
+    }
+    if (material !== void 0 && ts.isArrayLiteralExpression(material)) {
+      this.residue(expr, "unconverted", "material", "Mesh with a material array", "Split the geometry into groups or use one material per mesh.");
+      return null;
+    }
+    const owner = this.ownerBinding(expr);
+    const flags = [];
+    if (owner !== null && (owner.shadows & CAST_SHADOW_FLAG) !== 0) {
+      flags.push("CAST_SHADOW");
+      this.kitImports.add("CAST_SHADOW");
+    }
+    if (owner !== null && (owner.shadows & RECEIVE_SHADOW_FLAG) !== 0) {
+      flags.push("RECEIVE_SHADOW");
+      this.kitImports.add("RECEIVE_SHADOW");
+    }
+    const materialText = material === void 0 ? `game.graphics.createMaterial({ kind: "unlit", color: 0xffffff })` : this.emit(material);
+    this.count("object");
+    return `port.mesh(${this.emit(geometry)}, ${materialText}${flags.length === 0 ? "" : `, ${flags.join(" | ")}`})`;
+  }
+  assetPath(arg) {
+    if (!ts.isStringLiteralLike(arg)) {
+      this.residue(arg, "advisory", "loader", "computed asset path", `Asset paths must name files under ${this.options.assetPrefix}; check this one resolves.`);
+      return this.emit(arg);
+    }
+    const relative = arg.text.replace(/^\.?\//, "");
+    if (/^[a-z]+:/i.test(relative)) {
+      this.residue(arg, "unconverted", "loader", "remote asset URL", "Download the file into the project's assets/ folder; Interactives cannot fetch URLs.");
+      return JSON.stringify(arg.text);
+    }
+    this.assetPaths.add(relative);
+    return JSON.stringify(`${this.options.assetPrefix}${relative}`);
+  }
+  rewriteCall(expr) {
+    const callee = expr.expression;
+    if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression)) {
+      const owner2 = callee.expression.text;
+      if (owner2 === "Math" && callee.name.text === "random" && this.bindingOf(callee.expression) === null) {
+        this.count("math");
+        return "port.random()";
+      }
+      if (owner2 === "performance" && callee.name.text === "now") {
+        this.count("loop");
+        return "(port.elapsedSeconds() * 1000)";
+      }
+    }
+    if (!ts.isPropertyAccessExpression(callee)) return null;
+    const owner = this.threeName(callee.expression);
+    if (owner !== null) return this.rewriteThreeStatic(expr, owner, callee.name.text);
+    const method = callee.name.text;
+    const receiver = callee.expression;
+    const path2 = this.pathOf(callee);
+    if (path2 !== null && path2.names.length >= 2 && this.kindOf(path2.root) === "entity") return this.rewriteEntityPathCall(expr, path2.root, path2.names);
+    if (path2 !== null && path2.names.length >= 2 && this.kindOf(path2.root) === "material") return this.rewriteMaterialPathCall(expr, path2.root, path2.names);
+    const receiverKind = this.kindOf(receiver);
+    if (method === "addEventListener") return this.rewriteListener(expr, receiver);
+    if (receiverKind === "clock") return this.rewriteClock(expr, method);
+    if (receiverKind === "gltfLoader") return this.rewriteGltfLoad(expr, method);
+    if (receiverKind === "textureLoader" || ts.isNewExpression(receiver) && this.threeName(receiver.expression) === "TextureLoader") return this.rewriteTextureLoad(expr, method);
+    if (receiverKind === "mixer") return this.rewriteMixer(expr, receiver, method);
+    if (receiverKind === "action") return this.rewriteAction(expr, method);
+    if (receiverKind === "controls") return this.rewriteControls(expr, receiver, method);
+    if (receiverKind === "vector") return this.rewriteVector(expr, method);
+    if (receiverKind === "entity") return this.rewriteEntityCall(expr, receiver, method);
+    if (receiverKind === "material") return this.rewriteMaterialCall(expr, method);
+    return null;
+  }
+  rewriteThreeStatic(expr, owner, method) {
+    const args = expr.arguments.map((a) => this.emit(a));
+    if (owner === "MathUtils") {
+      if (THREE_MATH_HELPERS[method] !== void 0) {
+        this.kitImports.add("MathUtils");
+        this.count("math");
+        return `MathUtils.${THREE_MATH_HELPERS[method]}(${args.join(", ")})`;
+      }
+      if (method === "randFloat" && args.length === 2) {
+        this.count("math");
+        return `game.random.range(${args[0]}, ${args[1]})`;
+      }
+      if (method === "randInt" && args.length === 2) {
+        this.count("math");
+        return `game.random.int(${args[0]}, ${args[1]})`;
+      }
+      if (method === "randFloatSpread" && args.length === 1) {
+        this.count("math");
+        return `game.random.range(-(${args[0]}) / 2, (${args[0]}) / 2)`;
+      }
+    }
+    if (owner === "AnimationClip" && method === "findByName" && expr.arguments[1] !== void 0) {
+      this.count("animation");
+      return this.emit(expr.arguments[1]);
+    }
+    this.residue(expr, "unconverted", owner === "MathUtils" ? "math" : "scene", `${owner}.${method}`, "No automatic mapping; see the porting-threejs guide topic.");
+    return null;
+  }
+  rewriteListener(expr, receiver) {
+    const type = expr.arguments[0];
+    const handler = expr.arguments[1];
+    if (type === void 0 || handler === void 0 || !ts.isStringLiteralLike(type) || !this.isListenerTarget(receiver)) return null;
+    const keyType = KEY_EVENTS[type.text];
+    if (keyType !== void 0) {
+      this.keyListeners++;
+      this.count("input");
+      this.kitTypeImports.add("PortKeyEvent");
+      return `port.addKeyListener("${keyType}", ${this.emit(handler)})`;
+    }
+    const pointerType = POINTER_EVENTS[type.text];
+    if (pointerType !== void 0) {
+      this.count("input");
+      this.touchHandled = true;
+      return `port.addPointerListener("${pointerType}", ${this.emit(handler)})`;
+    }
+    this.residue(expr, "unconverted", "input", `${type.text} listener`, "Read game.input in fixedUpdate instead (pointerAt, look, wheel, gestures); see the input topic.");
+    return null;
+  }
+  rewriteClock(expr, method) {
+    this.count("loop");
+    if (method === "getDelta") return "game.stepSeconds";
+    if (method === "getElapsedTime") return "port.elapsedSeconds()";
+    this.residue(expr, "unconverted", "loop", `Clock.${method}`, "Use game.stepSeconds and port.elapsedSeconds().");
+    return null;
+  }
+  rewriteGltfLoad(expr, method) {
+    const url = expr.arguments[0];
+    if (url === void 0) return null;
+    this.features.add("models");
+    this.count("loader");
+    if (method === "loadAsync") return `port.model(${this.assetPath(url)})`;
+    if (method !== "load") {
+      this.residue(expr, "unconverted", "loader", `GLTFLoader.${method}`, "Draco and meshopt are handled by the engine baker; drop loader configuration.");
+      return null;
+    }
+    const onLoad = expr.arguments[1];
+    const onError = expr.arguments[3];
+    let out = `void port.model(${this.assetPath(url)})`;
+    if (onLoad !== void 0) out = `void port.model(${this.assetPath(url)}).then(${this.emit(onLoad)})`;
+    if (onError !== void 0) out += `.catch(${this.emit(onError)})`;
+    return out;
+  }
+  rewriteTextureLoad(expr, method) {
+    const url = expr.arguments[0];
+    if (method !== "load" && method !== "loadAsync") return null;
+    if (url === void 0 || expr.arguments.length > 1) {
+      this.residue(expr, "unconverted", "loader", "TextureLoader callbacks", "Use port.texture(path), which returns a promise of the texture id.");
+      return null;
+    }
+    this.features.add("images");
+    this.count("loader");
+    return `port.texture(${this.assetPath(url)})`;
+  }
+  rewriteMixer(expr, receiver, method) {
+    if (method === "clipAction" && expr.arguments[0] !== void 0) {
+      this.count("animation");
+      return `port.clipAction(${this.emit(receiver)}, ${this.emit(expr.arguments[0])})`;
+    }
+    this.residue(expr, "unconverted", "animation", `AnimationMixer.${method}`, "Keep the PortClipAction handles and stop or fade them one by one.");
+    return null;
+  }
+  rewriteAction(expr, method) {
+    if (method === "setLoop" && expr.arguments[0] !== void 0) {
+      const constant = this.threeName(expr.arguments[0]);
+      const loop = constant === null ? void 0 : LOOP_MODES[constant];
+      if (loop !== void 0 && ts.isPropertyAccessExpression(expr.expression)) {
+        this.count("animation");
+        return `${this.emit(expr.expression.expression)}.setLoop(${loop})`;
+      }
+    }
+    if (ACTION_PASSTHROUGH.has(method)) {
+      this.count("animation");
+      return null;
+    }
+    this.residue(expr, "unconverted", "animation", `AnimationAction.${method}`, "PortClipAction supports play, stop, fadeIn, fadeOut, reset, setLoop, setEffectiveTimeScale and setEffectiveWeight.");
+    return null;
+  }
+  rewriteControls(expr, receiver, method) {
+    if (method === "update") {
+      this.count("controls");
+      return `${this.emit(receiver)}.update(game.stepSeconds)`;
+    }
+    if (method === "getObject") {
+      const binding = this.bindingOf(receiver);
+      if (binding?.camera) {
+        this.count("controls");
+        return this.emit(binding.camera);
+      }
+    }
+    if (method === "moveForward" || method === "moveRight" || method === "dispose") {
+      this.count("controls");
+      return null;
+    }
+    this.residue(expr, "unconverted", "controls", `controls.${method}`, "Pointer lock and control events differ on phones; firstPerson(game, options) gives look and move on touch and mouse.");
+    return null;
+  }
+  rewriteVector(expr, method) {
+    const mapped = THREE_VECTOR_METHODS[method];
+    if (mapped !== void 0 && ts.isPropertyAccessExpression(expr.expression)) {
+      this.count("math");
+      return `${this.emit(expr.expression.expression)}.${mapped}(${expr.arguments.map((a) => this.emitVectorArg(a)).join(", ")})`;
+    }
+    if (method === "clone" && ts.isPropertyAccessExpression(expr.expression)) {
+      this.gameImports.add("Vec3");
+      this.count("math");
+      return `new Vec3().copy(${this.emit(expr.expression.expression)})`;
+    }
+    this.residue(expr, "unconverted", "math", `Vector3.${method}`, "Vec3 has set, copy, add, sub, scale, addScaled, dot, cross, length, normalize, lerp, distanceTo and friends.");
+    return null;
+  }
+  emitVectorArg(arg) {
+    if (ts.isPropertyAccessExpression(arg) && arg.name.text === "position" && this.kindOf(arg.expression) === "entity") {
+      this.gameImports.add("Vec3");
+      return `game.transforms.position(${this.emit(arg.expression)}, new Vec3())`;
+    }
+    return this.emit(arg);
+  }
+  rewriteEntityCall(expr, receiver, method) {
+    const entity = this.emit(receiver);
+    const args = expr.arguments;
+    if (method === "lookAt") {
+      this.count("object");
+      if (args.length === 3) return `port.lookAt(${entity}, ${args.map((a) => this.emit(a)).join(", ")})`;
+      const target = args[0];
+      if (target !== void 0 && ts.isPropertyAccessExpression(target) && target.name.text === "position" && this.kindOf(target.expression) === "entity") return `port.lookAtEntity(${entity}, ${this.emit(target.expression)})`;
+      if (target !== void 0 && this.kindOf(target) === "vector" && SIMPLE_OPERAND.test(target.getText(this.sf))) {
+        const v = this.emit(target);
+        return `port.lookAt(${entity}, ${v}.x, ${v}.y, ${v}.z)`;
+      }
+    }
+    if (method === "add" || method === "remove") {
+      this.count("object");
+      if (args.length === 1) return `port.${method}(${entity}, ${this.emitEntity(args[0])})`;
+    }
+    this.residue(expr, "unconverted", "object", `Object3D.${method}`, "No automatic mapping; use game.transforms (setPosition, setRotationQuat, translate, setParent) or ThreePort helpers.");
+    return null;
+  }
+  rewriteEntityPathCall(expr, root, names) {
+    const entity = this.emit(root);
+    const args = expr.arguments;
+    const values = args.map((a) => this.emit(a));
+    const [attribute, method] = names;
+    if (names.length === 2 && (attribute === "position" || attribute === "scale")) {
+      const setter = attribute === "position" ? "setPosition" : "setScale";
+      if (method === "set" && args.length === 3) {
+        this.count("object");
+        return `game.transforms.${setter}(${entity}, ${values.join(", ")})`;
+      }
+      if (attribute === "scale" && method === "setScalar" && args.length === 1) {
+        this.count("object");
+        return `port.setScalar(${entity}, ${values[0]})`;
+      }
+      if (attribute === "position" && args.length === 1) {
+        const other = args[0];
+        const otherEntity = ts.isPropertyAccessExpression(other) && other.name.text === "position" && this.kindOf(other.expression) === "entity" ? this.emit(other.expression) : null;
+        if (method === "copy" && otherEntity !== null) {
+          this.count("object");
+          return `port.copyPosition(${entity}, ${otherEntity})`;
+        }
+        if ((method === "distanceTo" || method === "distanceToSquared") && otherEntity !== null) {
+          this.count("object");
+          return `port.${method === "distanceTo" ? "distance" : "distanceSquared"}(${entity}, ${otherEntity})`;
+        }
+        if (method === "add" && this.kindOf(other) === "vector") {
+          this.count("object");
+          return `game.transforms.translate(${entity}, ${values[0]})`;
+        }
+        if (method === "copy" && this.kindOf(other) === "vector" && SIMPLE_OPERAND.test(values[0])) {
+          this.count("object");
+          return `game.transforms.setPosition(${entity}, ${values[0]}.x, ${values[0]}.y, ${values[0]}.z)`;
+        }
+      }
+    }
+    if (names.length === 2 && attribute === "rotation" && method === "set" && args.length >= 3) {
+      this.count("object");
+      return `port.setRotation(${entity}, ${values.slice(0, 3).join(", ")})`;
+    }
+    if (names.length === 3 && attribute === "material" && names[1] === "color" && (names[2] === "set" || names[2] === "setHex")) {
+      const material = this.materialOf(root);
+      const color = args[0] === void 0 ? null : this.colorExpr(args[0]);
+      if (material !== null && color !== null) {
+        this.count("material");
+        return `game.graphics.setMaterialColor(${material}, ${color})`;
+      }
+    }
+    this.residue(expr, "unconverted", "object", `Object3D.${names.join(".")}`, "No automatic mapping; use game.transforms or ThreePort helpers.");
+    return null;
+  }
+  materialOf(root) {
+    const binding = this.bindingOf(root);
+    if (binding === null || binding.material === null) return null;
+    const material = this.bindings.get(binding.material);
+    return material === void 0 ? null : this.memberRef(binding.material, material.name);
+  }
+  rewriteMaterialCall(expr, method) {
+    this.residue(expr, "unconverted", "material", `Material.${method}`, "Use game.graphics.setMaterialColor, setMaterialOpacity, setMaterialTexture or setMaterialState.");
+    return null;
+  }
+  rewriteMaterialPathCall(expr, root, names) {
+    const [property, method] = names;
+    const arg = expr.arguments[0];
+    if (property === "color" && (method === "set" || method === "setHex") && arg !== void 0) {
+      const color = this.colorExpr(arg);
+      if (color !== null) {
+        this.count("material");
+        return `game.graphics.setMaterialColor(${this.emit(root)}, ${color})`;
+      }
+    }
+    this.residue(expr, "unconverted", "material", `Material.${names.join(".")}`, "Use game.graphics.setMaterialColor, setMaterialOpacity or setMaterialTexture.");
+    return null;
+  }
+  rewriteBinary(expr) {
+    const op = expr.operatorToken.kind;
+    const compound = {
+      [ts.SyntaxKind.EqualsToken]: "=",
+      [ts.SyntaxKind.PlusEqualsToken]: "+",
+      [ts.SyntaxKind.MinusEqualsToken]: "-",
+      [ts.SyntaxKind.AsteriskEqualsToken]: "*",
+      [ts.SyntaxKind.SlashEqualsToken]: "/"
+    };
+    const operator = compound[op];
+    if (operator === void 0) return null;
+    const path2 = this.pathOf(expr.left);
+    if (path2 === null) return null;
+    const rootKind = this.kindOf(path2.root);
+    if (rootKind === "entity") return this.assignEntity(expr, path2.root, path2.names, operator);
+    if (ts.isCallExpression(path2.root) && path2.names.length === 1 && HUD_PROPERTIES.has(path2.names[0]) && operator === "=") {
+      const id = this.hudIdOf(path2.root);
+      const slot = id === null ? void 0 : this.hudSlots.get(id);
+      if (slot !== void 0) return this.assignHud(expr.right, `this.${slot}`);
+    }
+    if (rootKind === "hud" && path2.names.length === 1 && HUD_PROPERTIES.has(path2.names[0]) && operator === "=" && ts.isIdentifier(path2.root)) return this.assignHud(expr.right, this.emit(path2.root));
+    if (rootKind === "material" && path2.names.length === 1 && path2.names[0] === "opacity" && operator === "=") {
+      this.count("material");
+      return `game.graphics.setMaterialOpacity(${this.emit(path2.root)}, ${this.emit(expr.right)})`;
+    }
+    if (rootKind === "controls" && path2.names.length === 1 && path2.names[0] === "isLocked") return null;
+    return null;
+  }
+  assignHud(value, slot) {
+    this.count("dom");
+    const text = this.emit(value);
+    return `game.ui.setText(${slot}, ${this.kindOf(value) === "string" ? text : `String(${text})`})`;
+  }
+  assignEntity(expr, root, names, operator) {
+    const entity = this.emit(root);
+    const value = this.emit(expr.right);
+    const [attribute, axis] = names;
+    const suffix = TRANSFORM_ATTRIBUTES[attribute];
+    if (names.length === 2 && suffix !== void 0 && AXIS_NAMES[axis] !== void 0) {
+      const axisName = AXIS_NAMES[axis];
+      this.kitImports.add(axisName);
+      this.count("object");
+      if (operator === "=") return `port.set${suffix}Axis(${entity}, ${axisName}, ${value})`;
+      if (operator === "+") return `port.add${suffix}Axis(${entity}, ${axisName}, ${value})`;
+      if (operator === "-") return `port.add${suffix}Axis(${entity}, ${axisName}, -(${value}))`;
+      return `port.set${suffix}Axis(${entity}, ${axisName}, port.${attribute}Axis(${entity}, ${axisName}) ${operator} (${value}))`;
+    }
+    if (names.length === 1 && attribute === "visible" && operator === "=") {
+      this.count("object");
+      return `port.setVisible(${entity}, ${value})`;
+    }
+    if (names.length === 2 && attribute === "material" && axis === "opacity" && operator === "=") {
+      const material = this.materialOf(root);
+      if (material !== null) {
+        this.count("material");
+        return `game.graphics.setMaterialOpacity(${material}, ${value})`;
+      }
+    }
+    if (attribute === "castShadow" || attribute === "receiveShadow") {
+      this.residue(expr, "unconverted", "object", `Object3D.${attribute} at run time`, "Shadow flags are set when the mesh is created: pass CAST_SHADOW | RECEIVE_SHADOW to port.mesh.");
+      return null;
+    }
+    this.residue(expr, "unconverted", "object", `Object3D.${names.join(".")}`, attribute === "userData" ? "Keep per-object data in typed arrays indexed by entityIndex(entity) or in your own fields." : "No automatic mapping; use game.transforms or ThreePort helpers.");
+    return null;
+  }
+  rewriteIncrement(expr) {
+    if (expr.operator !== ts.SyntaxKind.PlusPlusToken && expr.operator !== ts.SyntaxKind.MinusMinusToken) return null;
+    const path2 = this.pathOf(expr.operand);
+    if (path2 === null || this.kindOf(path2.root) !== "entity" || path2.names.length !== 2) return null;
+    const suffix = TRANSFORM_ATTRIBUTES[path2.names[0]];
+    const axisName = AXIS_NAMES[path2.names[1]];
+    if (suffix === void 0 || axisName === void 0) return null;
+    this.kitImports.add(axisName);
+    this.count("object");
+    return `port.add${suffix}Axis(${this.emit(path2.root)}, ${axisName}, ${expr.operator === ts.SyntaxKind.PlusPlusToken ? "1" : "-1"})`;
+  }
+  rewriteProperty(expr) {
+    const parent = expr.parent;
+    this.flagEntityMember(expr);
+    this.flagHudMember(expr);
+    if (ts.isCallExpression(parent) && parent.expression === expr) return null;
+    if (ts.isPropertyAccessExpression(parent) && parent.expression === expr) return null;
+    if (ts.isBinaryExpression(parent) && parent.left === expr && parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment) return null;
+    if (ts.isNewExpression(parent) && parent.expression === expr) return null;
+    const member = this.threeMember(expr);
+    if (member !== null) {
+      this.count("math");
+      if (member[0] === "MathUtils" && member[1] === "DEG2RAD") return "(Math.PI / 180)";
+      if (member[0] === "MathUtils" && member[1] === "RAD2DEG") return "(180 / Math.PI)";
+      this.residue(expr, "unconverted", "scene", `${member[0]}.${member[1]}`, "No automatic mapping; see the porting-threejs guide topic.");
+      return null;
+    }
+    const constant = this.threeName(expr);
+    if (constant !== null) {
+      const side = THREE_SIDES[constant];
+      if (side !== void 0) {
+        this.count("material");
+        return JSON.stringify(side);
+      }
+      this.residue(expr, "unconverted", "scene", constant, "No automatic mapping; see the porting-threejs guide topic.");
+      return null;
+    }
+    const name = expr.name.text;
+    const ownerKind = this.kindOf(expr.expression);
+    if (ownerKind === "gltf" && name === "scene" && ts.isIdentifier(expr.expression)) {
+      this.count("loader");
+      return `${expr.expression.text}Scene`;
+    }
+    if (ownerKind === "gltf" && name === "animations") {
+      this.count("animation");
+      return `${this.emit(expr.expression)}.clipNames`;
+    }
+    if (ownerKind === "clock" && name === "elapsedTime") {
+      this.count("loop");
+      return "port.elapsedSeconds()";
+    }
+    if (ownerKind === "controls" && name === "isLocked") {
+      this.count("controls");
+      return `${this.emit(expr.expression)}.locked`;
+    }
+    if (ts.isPropertyAccessExpression(expr.expression) && this.kindOf(expr.expression.expression) === "entity") {
+      const suffix = TRANSFORM_ATTRIBUTES[expr.expression.name.text];
+      const axisName = AXIS_NAMES[name];
+      if (suffix !== void 0 && axisName !== void 0) {
+        this.kitImports.add(axisName);
+        this.count("object");
+        return `port.${expr.expression.name.text}Axis(${this.emit(expr.expression.expression)}, ${axisName})`;
+      }
+    }
+    if (ts.isIdentifier(expr.expression) && (expr.expression.text === "window" || expr.expression.text === "document") && this.bindingOf(expr.expression) === null) {
+      this.residue(expr, "unconverted", "dom", `${expr.expression.text}.${name}`, "The canvas profile has no page; use game.ui for text and the surface size the platform gives you.");
+    }
+    return null;
+  }
+  flagHudMember(expr) {
+    if (HUD_PROPERTIES.has(expr.name.text) || !ts.isIdentifier(expr.expression) || this.bindingOf(expr.expression)?.kind !== "hud") return;
+    this.residue(expr, "unconverted", "dom", `element.${expr.name.text}`, "HUD slots only carry text; draw other UI with game.ui panels (game.ui.show) or the engine game UI.");
+  }
+  flagEntityMember(expr) {
+    if (this.kindOf(expr.expression) !== "entity") return;
+    const name = expr.name.text;
+    const parent = expr.parent;
+    if (ts.isCallExpression(parent) && parent.expression === expr) return;
+    const chained = ts.isPropertyAccessExpression(parent) && parent.expression === expr;
+    if (TRANSFORM_ATTRIBUTES[name] !== void 0) {
+      if (chained || ts.isCallExpression(parent) && parent.arguments.includes(expr)) return;
+      this.residue(expr, "unconverted", "object", `Object3D.${name} as a value`, "Read axes with port.positionAxis or copy into a Vec3 with game.transforms.position(entity, out).");
+      return;
+    }
+    if (HANDLED_ENTITY_MEMBERS.has(name)) return;
+    this.residue(expr, "unconverted", "object", `Object3D.${name}`, name === "userData" ? "Keep per-object data in typed arrays indexed by entityIndex(entity) or in your own fields." : "No automatic mapping; use game.transforms or ThreePort helpers.");
+  }
+};
+
+// src/interactives/port/project.ts
+var PORT_REPORT_FILE = "port-report.json";
+var PORTED_SCENE_FILE = "src/scene.ts";
+var PORT_ASSET_PREFIX = "assets/core/";
+var MODULE_EXTENSIONS = [".js", ".mjs", ".ts", ".jsx", ".tsx"];
+var SKIPPED_DIRECTORIES = ["node_modules/", "vendor/", "dist/", "build/", ".git/"];
+var LOOP_MARKER = /requestAnimationFrame|setAnimationLoop/;
+var EXTENSION = /\.(m?js|jsx?|tsx?)$/;
+var GAME_SOURCE = /^src\/.*\.(ts|tsx|js|mjs)$/;
+function client(scene) {
+  return `import type { Ctx } from "@cimplify/sdk/interactives";
+import { runCanvasGame } from "@cimplify/sdk/game/kit/canvas";
+import { ${scene} } from "./scene";
+
+export default async function main(ctx: Ctx): Promise<void> {
+  await runCanvasGame(ctx, { scene: new ${scene}(ctx.assets) });
+}
+`;
+}
+function conformance(scene) {
+  return `import { createGame } from "@cimplify/sdk/game";
+import { platformBackend, PREPARED_PLATFORM } from "@cimplify/sdk/game/kit/canvas";
+import { ${scene} } from "./scene";
+
+const SEED = 1;
+const STEPS_PER_FRAME = 1;
+const WARM_FRAMES = 30000;
+
+export default async function createFrameHook(platform = PREPARED_PLATFORM): Promise<(frame: number) => void> {
+  const game = await createGame({ backend: await platformBackend(platform), seed: SEED });
+  const scene = new ${scene}();
+  game.addScene(scene);
+  game.start(scene.name);
+  for (let i = 0; i < WARM_FRAMES; i++) game.advance(STEPS_PER_FRAME);
+  return () => game.advance(STEPS_PER_FRAME);
+}
+`;
+}
+function isModule(path2) {
+  return MODULE_EXTENSIONS.some((e) => path2.endsWith(e)) && !path2.endsWith(".d.ts") && !SKIPPED_DIRECTORIES.some((d) => path2.startsWith(d) || path2.includes(`/${d}`));
+}
+function lines(path2, content) {
+  return { path: path2, lines: countSourceLines(content) };
+}
+function pickEntry(modules) {
+  const three = modules.filter((m) => importsThree(m.content));
+  return three.find((m) => LOOP_MARKER.test(m.content)) ?? three[0] ?? null;
+}
+function moduleResidue(file, index) {
+  return {
+    id: `M${index + 1}`,
+    kind: "unconverted",
+    area: "scene",
+    construct: "second Three.js module",
+    file: file.path,
+    line: 1,
+    column: 1,
+    source: file.path,
+    hint: "Only the entry module is converted. Fold this module into src/scene.ts or rewrite it against the game API, then import it relatively."
+  };
+}
+function portThreeProject(name, inputs) {
+  const modules = inputs.filter((f) => isModule(f.path));
+  const entry = pickEntry(modules);
+  if (entry === null) throw new Error("no module imports three; point cimplify port threejs at the folder that holds the game's JavaScript");
+  const converted = new ThreeModuleConverter(entry.path, entry.content, { sceneName: name, assetPrefix: PORT_ASSET_PREFIX }).convert();
+  const residue = [...converted.residue];
+  if (!converted.loopFound) {
+    residue.push({
+      id: `L${residue.length + 1}`,
+      kind: "unconverted",
+      area: "loop",
+      construct: "game loop",
+      file: entry.path,
+      line: 1,
+      column: 1,
+      source: entry.path,
+      hint: "No requestAnimationFrame or setAnimationLoop loop was found; call the per-frame code from fixedUpdate in src/scene.ts."
+    });
+  }
+  const extra = [];
+  modules.filter((m) => m !== entry).forEach((m) => {
+    const target = `src/${m.path.replace(EXTENSION, (ext) => ext.startsWith(".ts") ? ext : ".js")}`;
+    extra.push({ path: target, content: m.content });
+    if (importsThree(m.content)) residue.push(moduleResidue(m, residue.length));
+  });
+  const spec = {
+    description: `${titleFromName(name)} ported from Three.js`,
+    category: "games",
+    profile: "canvas",
+    game: true,
+    capabilities: {},
+    engineFeatures: converted.engineFeatures,
+    files: [{ path: "src/client.ts", content: client(sceneClassName(name)) }, { path: PORTED_SCENE_FILE, content: converted.scene }, { path: "src/conformance.ts", content: conformance(sceneClassName(name)) }, ...extra]
+  };
+  const files = materialize(name, spec);
+  const source = modules.map((m) => lines(m.path, m.content));
+  const output = files.filter((f) => GAME_SOURCE.test(f.path)).map((f) => lines(f.path, f.content));
+  const scene = output.find((f) => f.path === PORTED_SCENE_FILE);
+  const report = {
+    source,
+    output,
+    linesBefore: source.reduce((sum, f) => sum + f.lines, 0),
+    linesAfter: output.reduce((sum, f) => sum + f.lines, 0),
+    gameLinesAfter: scene?.lines ?? 0,
+    converted: converted.converted,
+    convertedByArea: converted.convertedByArea,
+    residue: residue.map((r, i) => ({ ...r, id: `R${i + 1}` }))
+  };
+  const assets = converted.assets.map((from) => ({ from, to: `${PORT_ASSET_PREFIX}${from}` }));
+  return { files: [...files, { path: PORT_REPORT_FILE, content: `${JSON.stringify(report, null, 2)}
+` }], report, assets };
+}
+
+// src/interactives/commands/port.ts
+var USAGE = "usage: cimplify port threejs <dir> [--out <dir>] [--name <name>] [--force] [--ai]";
+var SOURCES = ["threejs", "three"];
+var SKIPPED_DIRECTORIES2 = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "vendor", ".cimplify"]);
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".jsx", ".ts", ".tsx", ".html", ".css", ".json"]);
+var MAX_SOURCE_BYTES = 2e6;
+var NAME_PATTERN = /[^a-z0-9-]+/g;
+var OUT_SUFFIX = "-cimplify";
+async function readSources(root) {
+  const files = [];
+  const walk = async (dir, rel) => {
+    for (const entry of await promises.readdir(dir, { withFileTypes: true })) {
+      const relPath = rel === "" ? entry.name : `${rel}/${entry.name}`;
+      if (entry.isDirectory()) {
+        if (!SKIPPED_DIRECTORIES2.has(entry.name)) await walk(path.join(dir, entry.name), relPath);
+        continue;
+      }
+      if (!entry.isFile() || !TEXT_EXTENSIONS.has(path.extname(entry.name))) continue;
+      const stat = await promises.stat(path.join(dir, entry.name));
+      if (stat.size > MAX_SOURCE_BYTES) continue;
+      files.push({ path: relPath, content: await promises.readFile(path.join(dir, entry.name), "utf8") });
+    }
+  };
+  await walk(root, "");
+  return files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+async function ensureEmpty(out, force) {
+  if (!existsSync(out)) return;
+  const entries = await promises.readdir(out);
+  if (entries.length > 0 && !force) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `${out} is not empty`, { remediation: "Choose another --out folder, or pass --force to overwrite the files the port writes." });
+  }
+}
+async function writePortedProject(project, from, out) {
+  const missing = [];
+  for (const file of project.files) {
+    const target = path.join(out, ...file.path.split("/"));
+    await promises.mkdir(path.dirname(target), { recursive: true });
+    await promises.writeFile(target, file.content);
+  }
+  for (const asset of project.assets) {
+    const source = path.join(from, ...asset.from.split("/"));
+    if (!existsSync(source)) {
+      missing.push(asset.from);
+      continue;
+    }
+    const target = path.join(out, ...asset.to.split("/"));
+    await promises.mkdir(path.dirname(target), { recursive: true });
+    await promises.copyFile(source, target);
+  }
+  return missing;
+}
+function summarize(report) {
+  const unconverted = report.residue.filter((r) => r.kind === "unconverted").length;
+  const advisory = report.residue.length - unconverted;
+  info(`  converted ${report.converted} Three.js constructs`);
+  info(`  lines: ${report.linesBefore} before, ${report.linesAfter} after (${report.gameLinesAfter} in src/scene.ts)`);
+  info(`  residue: ${unconverted} unconverted, ${advisory} advisory`);
+  for (const item of report.residue) info(dim(`  ${item.kind === "unconverted" ? "todo" : "note"} ${item.file}:${item.line} ${item.construct}: ${item.hint}`));
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const [kind, dir] = args.positional;
+  if (kind === void 0 || dir === void 0 || !SOURCES.includes(kind)) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, USAGE);
+  const from = path.resolve(process.cwd(), dir);
+  if (!existsSync(from)) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `${from} does not exist`);
+  const name = (flagString(args, "name") ?? path.basename(from)).toLowerCase().replace(NAME_PATTERN, "-").replace(/^-+|-+$/g, "") || "ported-game";
+  const out = path.resolve(process.cwd(), flagString(args, "out") ?? `${name}${OUT_SUFFIX}`);
+  await ensureEmpty(out, flagBool(args, "force"));
+  step(`Porting the Three.js game in ${from}`);
+  let project;
+  try {
+    project = portThreeProject(name, await readSources(from));
+  } catch (error) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, error instanceof Error ? error.message : String(error));
+  }
+  const missing = await writePortedProject(project, from, out);
+  for (const asset of missing) warn(`asset ${asset} was not found next to the game; copy it into ${out}/assets/core/`);
+  success(`Wrote ${out}`);
+  summarize(project.report);
+  let ai = null;
+  if (flagBool(args, "ai") && project.report.residue.length > 0) {
+    step("Asking Reesa to finish the port");
+    const outcome = await askAuthoring(out, threejsPortRequest(project.report), {
+      model: modelFromEnv(),
+      onEvent: (event) => {
+        const line = describeEvent(event);
+        if (line !== null) info(dim(`  ${line}`));
+      }
+    });
+    reportOutcome(outcome);
+    ai = { changed: outcome.changed.length, diagnostics: outcome.diagnostics.length, end: outcome.end };
+  } else if (project.report.residue.length > 0) {
+    info(`Run cimplify ai in ${out} with the request from port-report.json, or rerun with --ai, to let Reesa finish the residue.`);
+  }
+  result({ out, report: project.report, missingAssets: missing, ai });
+}
+
+export { run as default, writePortedProject };